1
// GENERATED BY ISLE. DO NOT EDIT!
2
//
3
// Generated automatically from the instruction-selection DSL code in:
4
// - src/prelude.isle
5
// - src/prelude_lower.isle
6
// - src/isa/x64/inst.isle
7
// - src/isa/x64/lower.isle
8
// - /home/tomasz/projects/fuzz-tanssi-runtime/fuzz/target/x86_64-unknown-linux-gnu/debug/build/cranelift-codegen-246b63cff59c567e/out/clif_lower.isle
9

            
10
use super::*; // Pulls in all external types.
11
use std::marker::PhantomData;
12

            
13
/// Context during lowering: an implementation of this trait
14
/// must be provided with all external constructors and extractors.
15
/// A mutable borrow is passed along through all lowering logic.
16
pub trait Context {
17
    fn unit(&mut self) -> Unit;
18
    fn value_type(&mut self, arg0: Value) -> Type;
19
    fn u32_nonnegative(&mut self, arg0: u32) -> Option<u32>;
20
    fn offset32(&mut self, arg0: Offset32) -> u32;
21
    fn u32_lteq(&mut self, arg0: u32, arg1: u32) -> Option<Unit>;
22
    fn u8_lteq(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
23
    fn u8_lt(&mut self, arg0: u8, arg1: u8) -> Option<Unit>;
24
    fn simm32(&mut self, arg0: Imm64) -> Option<u32>;
25
    fn uimm8(&mut self, arg0: Imm64) -> Option<u8>;
26
    fn u8_as_u32(&mut self, arg0: u8) -> u32;
27
    fn u8_as_u64(&mut self, arg0: u8) -> u64;
28
    fn u16_as_u64(&mut self, arg0: u16) -> u64;
29
    fn u32_as_u64(&mut self, arg0: u32) -> u64;
30
    fn i64_as_u64(&mut self, arg0: i64) -> u64;
31
    fn i64_neg(&mut self, arg0: i64) -> i64;
32
    fn u128_as_u64(&mut self, arg0: u128) -> Option<u64>;
33
    fn u64_as_u32(&mut self, arg0: u64) -> Option<u32>;
34
    fn u64_as_i32(&mut self, arg0: u64) -> i32;
35
    fn u8_and(&mut self, arg0: u8, arg1: u8) -> u8;
36
    fn u32_add(&mut self, arg0: u32, arg1: u32) -> u32;
37
    fn s32_add_fallible(&mut self, arg0: u32, arg1: u32) -> Option<u32>;
38
    fn u64_add(&mut self, arg0: u64, arg1: u64) -> u64;
39
    fn u64_sub(&mut self, arg0: u64, arg1: u64) -> u64;
40
    fn u64_mul(&mut self, arg0: u64, arg1: u64) -> u64;
41
    fn u64_sdiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
42
    fn u64_udiv(&mut self, arg0: u64, arg1: u64) -> Option<u64>;
43
    fn u64_and(&mut self, arg0: u64, arg1: u64) -> u64;
44
    fn u64_or(&mut self, arg0: u64, arg1: u64) -> u64;
45
    fn u64_xor(&mut self, arg0: u64, arg1: u64) -> u64;
46
    fn u64_shl(&mut self, arg0: u64, arg1: u64) -> u64;
47
    fn imm64_shl(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
48
    fn imm64_ushr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
49
    fn imm64_sshr(&mut self, arg0: Type, arg1: Imm64, arg2: Imm64) -> Imm64;
50
    fn u64_not(&mut self, arg0: u64) -> u64;
51
    fn u64_eq(&mut self, arg0: u64, arg1: u64) -> bool;
52
    fn u64_le(&mut self, arg0: u64, arg1: u64) -> bool;
53
    fn u64_lt(&mut self, arg0: u64, arg1: u64) -> bool;
54
    fn i64_sextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> i64;
55
    fn u64_uextend_imm64(&mut self, arg0: Type, arg1: Imm64) -> u64;
56
    fn imm64_icmp(&mut self, arg0: Type, arg1: &IntCC, arg2: Imm64, arg3: Imm64) -> Imm64;
57
    fn u64_is_zero(&mut self, arg0: u64) -> bool;
58
    fn u64_is_odd(&mut self, arg0: u64) -> bool;
59
    fn ty_umin(&mut self, arg0: Type) -> u64;
60
    fn ty_umax(&mut self, arg0: Type) -> u64;
61
    fn ty_smin(&mut self, arg0: Type) -> u64;
62
    fn ty_smax(&mut self, arg0: Type) -> u64;
63
    fn ty_bits(&mut self, arg0: Type) -> u8;
64
    fn ty_bits_u16(&mut self, arg0: Type) -> u16;
65
    fn ty_bits_u64(&mut self, arg0: Type) -> u64;
66
    fn ty_mask(&mut self, arg0: Type) -> u64;
67
    fn ty_bytes(&mut self, arg0: Type) -> u16;
68
    fn lane_type(&mut self, arg0: Type) -> Type;
69
    fn mem_flags_trusted(&mut self) -> MemFlags;
70
    fn intcc_reverse(&mut self, arg0: &IntCC) -> IntCC;
71
    fn intcc_inverse(&mut self, arg0: &IntCC) -> IntCC;
72
    fn floatcc_reverse(&mut self, arg0: &FloatCC) -> FloatCC;
73
    fn floatcc_inverse(&mut self, arg0: &FloatCC) -> FloatCC;
74
    fn floatcc_unordered(&mut self, arg0: &FloatCC) -> bool;
75
    fn fits_in_16(&mut self, arg0: Type) -> Option<Type>;
76
    fn fits_in_32(&mut self, arg0: Type) -> Option<Type>;
77
    fn lane_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
78
    fn fits_in_64(&mut self, arg0: Type) -> Option<Type>;
79
    fn ty_32(&mut self, arg0: Type) -> Option<Type>;
80
    fn ty_64(&mut self, arg0: Type) -> Option<Type>;
81
    fn ty_int_ref_scalar_64(&mut self, arg0: Type) -> Option<Type>;
82
    fn ty_32_or_64(&mut self, arg0: Type) -> Option<Type>;
83
    fn ty_8_or_16(&mut self, arg0: Type) -> Option<Type>;
84
    fn int_fits_in_32(&mut self, arg0: Type) -> Option<Type>;
85
    fn ty_int_ref_64(&mut self, arg0: Type) -> Option<Type>;
86
    fn ty_int(&mut self, arg0: Type) -> Option<Type>;
87
    fn ty_scalar_float(&mut self, arg0: Type) -> Option<Type>;
88
    fn ty_float_or_vec(&mut self, arg0: Type) -> Option<Type>;
89
    fn ty_vector_float(&mut self, arg0: Type) -> Option<Type>;
90
    fn ty_vector_not_float(&mut self, arg0: Type) -> Option<Type>;
91
    fn ty_vec64(&mut self, arg0: Type) -> Option<Type>;
92
    fn ty_vec64_ctor(&mut self, arg0: Type) -> Option<Type>;
93
    fn ty_vec128(&mut self, arg0: Type) -> Option<Type>;
94
    fn ty_dyn_vec64(&mut self, arg0: Type) -> Option<Type>;
95
    fn ty_dyn_vec128(&mut self, arg0: Type) -> Option<Type>;
96
    fn ty_vec64_int(&mut self, arg0: Type) -> Option<Type>;
97
    fn ty_vec128_int(&mut self, arg0: Type) -> Option<Type>;
98
    fn ty_addr64(&mut self, arg0: Type) -> Option<Type>;
99
    fn not_vec32x2(&mut self, arg0: Type) -> Option<Type>;
100
    fn not_i64x2(&mut self, arg0: Type) -> Option<()>;
101
    fn u8_from_uimm8(&mut self, arg0: Uimm8) -> u8;
102
    fn u64_from_bool(&mut self, arg0: bool) -> u64;
103
    fn u64_from_imm64(&mut self, arg0: Imm64) -> u64;
104
    fn nonzero_u64_from_imm64(&mut self, arg0: Imm64) -> Option<u64>;
105
    fn imm64_power_of_two(&mut self, arg0: Imm64) -> Option<u64>;
106
    fn imm64(&mut self, arg0: u64) -> Imm64;
107
    fn imm64_masked(&mut self, arg0: Type, arg1: u64) -> Imm64;
108
    fn u32_from_ieee32(&mut self, arg0: Ieee32) -> u32;
109
    fn u64_from_ieee64(&mut self, arg0: Ieee64) -> u64;
110
    fn multi_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
111
    fn dynamic_lane(&mut self, arg0: Type) -> Option<(u32, u32)>;
112
    fn dynamic_int_lane(&mut self, arg0: Type) -> Option<u32>;
113
    fn dynamic_fp_lane(&mut self, arg0: Type) -> Option<u32>;
114
    fn ty_dyn64_int(&mut self, arg0: Type) -> Option<Type>;
115
    fn ty_dyn128_int(&mut self, arg0: Type) -> Option<Type>;
116
    fn offset32_to_u32(&mut self, arg0: Offset32) -> u32;
117
    fn u32_to_offset32(&mut self, arg0: u32) -> Offset32;
118
    fn intcc_unsigned(&mut self, arg0: &IntCC) -> IntCC;
119
    fn signed_cond_code(&mut self, arg0: &IntCC) -> Option<IntCC>;
120
    fn trap_code_division_by_zero(&mut self) -> TrapCode;
121
    fn trap_code_integer_overflow(&mut self) -> TrapCode;
122
    fn trap_code_bad_conversion_to_integer(&mut self) -> TrapCode;
123
    fn range(&mut self, arg0: usize, arg1: usize) -> Range;
124
    fn range_view(&mut self, arg0: Range) -> RangeView;
125
    fn value_reg(&mut self, arg0: Reg) -> ValueRegs;
126
    fn value_regs(&mut self, arg0: Reg, arg1: Reg) -> ValueRegs;
127
    fn value_regs_invalid(&mut self) -> ValueRegs;
128
    fn output_none(&mut self) -> InstOutput;
129
    fn output(&mut self, arg0: ValueRegs) -> InstOutput;
130
    fn output_pair(&mut self, arg0: ValueRegs, arg1: ValueRegs) -> InstOutput;
131
    fn output_builder_new(&mut self) -> InstOutputBuilder;
132
    fn output_builder_push(&mut self, arg0: &InstOutputBuilder, arg1: ValueRegs) -> Unit;
133
    fn output_builder_finish(&mut self, arg0: &InstOutputBuilder) -> InstOutput;
134
    fn temp_writable_reg(&mut self, arg0: Type) -> WritableReg;
135
    fn is_valid_reg(&mut self, arg0: Reg) -> bool;
136
    fn invalid_reg(&mut self) -> Reg;
137
    fn mark_value_used(&mut self, arg0: Value) -> Unit;
138
    fn put_in_reg(&mut self, arg0: Value) -> Reg;
139
    fn put_in_regs(&mut self, arg0: Value) -> ValueRegs;
140
    fn ensure_in_vreg(&mut self, arg0: Reg, arg1: Type) -> Reg;
141
    fn value_regs_get(&mut self, arg0: ValueRegs, arg1: usize) -> Reg;
142
    fn value_regs_len(&mut self, arg0: ValueRegs) -> usize;
143
    fn preg_to_reg(&mut self, arg0: PReg) -> Reg;
144
    fn value_list_slice(&mut self, arg0: ValueList) -> ValueSlice;
145
    fn value_slice_empty(&mut self, arg0: ValueSlice) -> Option<()>;
146
    fn value_slice_unwrap(&mut self, arg0: ValueSlice) -> Option<(Value, ValueSlice)>;
147
    fn value_slice_len(&mut self, arg0: ValueSlice) -> usize;
148
    fn value_slice_get(&mut self, arg0: ValueSlice, arg1: usize) -> Value;
149
    fn writable_reg_to_reg(&mut self, arg0: WritableReg) -> Reg;
150
    fn inst_results(&mut self, arg0: Inst) -> ValueSlice;
151
    fn first_result(&mut self, arg0: Inst) -> Option<Value>;
152
    fn inst_data(&mut self, arg0: Inst) -> InstructionData;
153
    fn def_inst(&mut self, arg0: Value) -> Option<Inst>;
154
    fn zero_value(&mut self, arg0: Value) -> Option<Value>;
155
    fn is_sinkable_inst(&mut self, arg0: Value) -> Option<Inst>;
156
    fn maybe_uextend(&mut self, arg0: Value) -> Option<Value>;
157
    fn emit(&mut self, arg0: &MInst) -> Unit;
158
    fn sink_inst(&mut self, arg0: Inst) -> Unit;
159
    fn emit_u64_le_const(&mut self, arg0: u64) -> VCodeConstant;
160
    fn emit_u128_le_const(&mut self, arg0: u128) -> VCodeConstant;
161
    fn const_to_vconst(&mut self, arg0: Constant) -> VCodeConstant;
162
    fn tls_model(&mut self, arg0: Type) -> TlsModel;
163
    fn tls_model_is_elf_gd(&mut self) -> Option<Unit>;
164
    fn tls_model_is_macho(&mut self) -> Option<Unit>;
165
    fn tls_model_is_coff(&mut self) -> Option<Unit>;
166
    fn preserve_frame_pointers(&mut self) -> Option<Unit>;
167
    fn box_external_name(&mut self, arg0: ExternalName) -> BoxExternalName;
168
    fn func_ref_data(&mut self, arg0: FuncRef) -> (SigRef, ExternalName, RelocDistance);
169
    fn symbol_value_data(
170
        &mut self,
171
        arg0: GlobalValue,
172
    ) -> Option<(ExternalName, RelocDistance, i64)>;
173
    fn reloc_distance_near(&mut self, arg0: RelocDistance) -> Option<()>;
174
    fn vec_mask_from_immediate(&mut self, arg0: Immediate) -> Option<VecMask>;
175
    fn u128_from_immediate(&mut self, arg0: Immediate) -> Option<u128>;
176
    fn u128_from_constant(&mut self, arg0: Constant) -> Option<u128>;
177
    fn u64_from_constant(&mut self, arg0: Constant) -> Option<u64>;
178
    fn shuffle64_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8)>;
179
    fn shuffle32_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8)>;
180
    fn shuffle16_from_imm(&mut self, arg0: Immediate) -> Option<(u8, u8, u8, u8, u8, u8, u8, u8)>;
181
    fn only_writable_reg(&mut self, arg0: WritableValueRegs) -> Option<WritableReg>;
182
    fn writable_regs_get(&mut self, arg0: WritableValueRegs, arg1: usize) -> WritableReg;
183
    fn abi_num_args(&mut self, arg0: Sig) -> usize;
184
    fn abi_get_arg(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
185
    fn abi_num_rets(&mut self, arg0: Sig) -> usize;
186
    fn abi_get_ret(&mut self, arg0: Sig, arg1: usize) -> ABIArg;
187
    fn abi_ret_arg(&mut self, arg0: Sig) -> Option<ABIArg>;
188
    fn abi_no_ret_arg(&mut self, arg0: Sig) -> Option<()>;
189
    fn abi_sized_stack_arg_space(&mut self, arg0: Sig) -> i64;
190
    fn abi_sized_stack_ret_space(&mut self, arg0: Sig) -> i64;
191
    fn abi_stackslot_addr(&mut self, arg0: WritableReg, arg1: StackSlot, arg2: Offset32) -> MInst;
192
    fn abi_dynamic_stackslot_addr(&mut self, arg0: WritableReg, arg1: DynamicStackSlot) -> MInst;
193
    fn abi_arg_only_slot(&mut self, arg0: &ABIArg) -> Option<ABIArgSlot>;
194
    fn abi_arg_struct_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, u64)>;
195
    fn abi_arg_implicit_pointer(&mut self, arg0: &ABIArg) -> Option<(ABIArgSlot, i64, Type)>;
196
    fn real_reg_to_reg(&mut self, arg0: RealReg) -> Reg;
197
    fn real_reg_to_writable_reg(&mut self, arg0: RealReg) -> WritableReg;
198
    fn gen_move(&mut self, arg0: Type, arg1: WritableReg, arg2: Reg) -> MInst;
199
    fn gen_return(&mut self, arg0: ValueSlice) -> Unit;
200
    fn safe_divisor_from_imm64(&mut self, arg0: Type, arg1: Imm64) -> Option<u64>;
201
    fn jump_table_size(&mut self, arg0: &BoxVecMachLabel) -> u32;
202
    fn single_target(&mut self, arg0: &MachLabelSlice) -> Option<MachLabel>;
203
    fn two_targets(&mut self, arg0: &MachLabelSlice) -> Option<(MachLabel, MachLabel)>;
204
    fn jump_table_targets(&mut self, arg0: &MachLabelSlice)
205
        -> Option<(MachLabel, BoxVecMachLabel)>;
206
    fn operand_size_of_type_32_64(&mut self, arg0: Type) -> OperandSize;
207
    fn raw_operand_size_of_type(&mut self, arg0: Type) -> OperandSize;
208
    fn put_in_reg_mem_imm(&mut self, arg0: Value) -> RegMemImm;
209
    fn put_in_reg_mem(&mut self, arg0: Value) -> RegMem;
210
    fn synthetic_amode_to_reg_mem(&mut self, arg0: &SyntheticAmode) -> RegMem;
211
    fn amode_to_synthetic_amode(&mut self, arg0: &Amode) -> SyntheticAmode;
212
    fn sum_extend_fits_in_32_bits(
213
        &mut self,
214
        arg0: Type,
215
        arg1: Imm64,
216
        arg2: Offset32,
217
    ) -> Option<u32>;
218
    fn amode_offset(&mut self, arg0: &Amode, arg1: u32) -> Amode;
219
    fn zero_offset(&mut self) -> Offset32;
220
    fn intcc_to_cc(&mut self, arg0: &IntCC) -> CC;
221
    fn cc_invert(&mut self, arg0: &CC) -> CC;
222
    fn cc_nz_or_z(&mut self, arg0: &CC) -> Option<CC>;
223
    fn encode_fcmp_imm(&mut self, arg0: &FcmpImm) -> u8;
224
    fn encode_round_imm(&mut self, arg0: &RoundImm) -> u8;
225
    fn imm8_reg_to_imm8_gpr(&mut self, arg0: &Imm8Reg) -> Imm8Gpr;
226
    fn writable_gpr_to_reg(&mut self, arg0: WritableGpr) -> WritableReg;
227
    fn writable_xmm_to_reg(&mut self, arg0: WritableXmm) -> WritableReg;
228
    fn writable_reg_to_xmm(&mut self, arg0: WritableReg) -> WritableXmm;
229
    fn writable_xmm_to_xmm(&mut self, arg0: WritableXmm) -> Xmm;
230
    fn writable_gpr_to_gpr(&mut self, arg0: WritableGpr) -> Gpr;
231
    fn gpr_to_reg(&mut self, arg0: Gpr) -> Reg;
232
    fn gpr_to_gpr_mem(&mut self, arg0: Gpr) -> GprMem;
233
    fn gpr_to_gpr_mem_imm(&mut self, arg0: Gpr) -> GprMemImm;
234
    fn xmm_to_reg(&mut self, arg0: Xmm) -> Reg;
235
    fn xmm_to_xmm_mem_imm(&mut self, arg0: Xmm) -> XmmMemImm;
236
    fn xmm_mem_to_xmm_mem_imm(&mut self, arg0: &XmmMem) -> XmmMemImm;
237
    fn xmm_mem_to_xmm_mem_aligned(&mut self, arg0: &XmmMem) -> XmmMemAligned;
238
    fn xmm_mem_imm_to_xmm_mem_aligned_imm(&mut self, arg0: &XmmMemImm) -> XmmMemAlignedImm;
239
    fn temp_writable_gpr(&mut self) -> WritableGpr;
240
    fn temp_writable_xmm(&mut self) -> WritableXmm;
241
    fn reg_mem_to_xmm_mem(&mut self, arg0: &RegMem) -> XmmMem;
242
    fn reg_to_reg_mem_imm(&mut self, arg0: Reg) -> RegMemImm;
243
    fn gpr_mem_imm_new(&mut self, arg0: &RegMemImm) -> GprMemImm;
244
    fn xmm_mem_imm_new(&mut self, arg0: &RegMemImm) -> XmmMemImm;
245
    fn xmm_to_xmm_mem(&mut self, arg0: Xmm) -> XmmMem;
246
    fn xmm_mem_to_reg_mem(&mut self, arg0: &XmmMem) -> RegMem;
247
    fn gpr_mem_to_reg_mem(&mut self, arg0: &GprMem) -> RegMem;
248
    fn xmm_new(&mut self, arg0: Reg) -> Xmm;
249
    fn gpr_new(&mut self, arg0: Reg) -> Gpr;
250
    fn reg_mem_to_gpr_mem(&mut self, arg0: &RegMem) -> GprMem;
251
    fn reg_to_gpr_mem(&mut self, arg0: Reg) -> GprMem;
252
    fn put_in_xmm_mem(&mut self, arg0: Value) -> XmmMem;
253
    fn put_in_xmm_mem_imm(&mut self, arg0: Value) -> XmmMemImm;
254
    fn gpr_to_imm8_gpr(&mut self, arg0: Gpr) -> Imm8Gpr;
255
    fn imm8_to_imm8_gpr(&mut self, arg0: u8) -> Imm8Gpr;
256
    fn xmi_imm(&mut self, arg0: u32) -> XmmMemImm;
257
    fn intcc_without_eq(&mut self, arg0: &IntCC) -> IntCC;
258
    fn type_register_class(&mut self, arg0: Type) -> Option<RegisterClass>;
259
    fn avx512vl_enabled(&mut self, arg0: Type) -> bool;
260
    fn avx512dq_enabled(&mut self, arg0: Type) -> bool;
261
    fn avx512f_enabled(&mut self, arg0: Type) -> bool;
262
    fn avx512bitalg_enabled(&mut self, arg0: Type) -> bool;
263
    fn avx512vbmi_enabled(&mut self, arg0: Type) -> bool;
264
    fn use_lzcnt(&mut self, arg0: Type) -> bool;
265
    fn use_bmi1(&mut self, arg0: Type) -> bool;
266
    fn use_popcnt(&mut self, arg0: Type) -> bool;
267
    fn use_fma(&mut self) -> bool;
268
    fn use_sse41(&mut self, arg0: Type) -> bool;
269
    fn use_avx_simd(&mut self) -> bool;
270
    fn use_avx2_simd(&mut self) -> bool;
271
    fn imm8_from_value(&mut self, arg0: Value) -> Option<Imm8Reg>;
272
    fn const_to_type_masked_imm8(&mut self, arg0: u64, arg1: Type) -> Imm8Gpr;
273
    fn shift_mask(&mut self, arg0: Type) -> u32;
274
    fn shift_amount_masked(&mut self, arg0: Type, arg1: Imm64) -> u32;
275
    fn simm32_from_value(&mut self, arg0: Value) -> Option<GprMemImm>;
276
    fn simm32_from_imm64(&mut self, arg0: Imm64) -> Option<GprMemImm>;
277
    fn sinkable_load(&mut self, arg0: Value) -> Option<SinkableLoad>;
278
    fn sinkable_load_exact(&mut self, arg0: Value) -> Option<SinkableLoad>;
279
    fn sink_load(&mut self, arg0: &SinkableLoad) -> SyntheticAmode;
280
    fn ext_mode(&mut self, arg0: u16, arg1: u16) -> ExtMode;
281
    fn gen_call(
282
        &mut self,
283
        arg0: SigRef,
284
        arg1: ExternalName,
285
        arg2: RelocDistance,
286
        arg3: ValueSlice,
287
    ) -> InstOutput;
288
    fn gen_call_indirect(&mut self, arg0: SigRef, arg1: Value, arg2: ValueSlice) -> InstOutput;
289
    fn nonzero_u64_fits_in_u32(&mut self, arg0: u64) -> Option<u64>;
290
    fn fcvt_uint_mask_const(&mut self) -> VCodeConstant;
291
    fn fcvt_uint_mask_high_const(&mut self) -> VCodeConstant;
292
    fn iadd_pairwise_mul_const_16(&mut self) -> VCodeConstant;
293
    fn iadd_pairwise_mul_const_32(&mut self) -> VCodeConstant;
294
    fn iadd_pairwise_xor_const_32(&mut self) -> VCodeConstant;
295
    fn iadd_pairwise_addd_const_32(&mut self) -> VCodeConstant;
296
    fn snarrow_umax_mask(&mut self) -> VCodeConstant;
297
    fn ty_int_bool_or_ref(&mut self, arg0: Type) -> Option<()>;
298
    fn atomic_rmw_op_to_mach_atomic_rmw_op(&mut self, arg0: &AtomicRmwOp) -> MachAtomicRmwOp;
299
    fn shuffle_0_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
300
    fn shuffle_0_15_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
301
    fn shuffle_16_31_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
302
    fn perm_from_mask(&mut self, arg0: &VecMask) -> VCodeConstant;
303
    fn perm_from_mask_with_zeros(
304
        &mut self,
305
        arg0: &VecMask,
306
    ) -> Option<(VCodeConstant, VCodeConstant)>;
307
    fn swizzle_zero_mask(&mut self) -> VCodeConstant;
308
    fn sqmul_round_sat_mask(&mut self) -> VCodeConstant;
309
    fn uunarrow_umax_mask(&mut self) -> VCodeConstant;
310
    fn uunarrow_uint_mask(&mut self) -> VCodeConstant;
311
    fn const_to_synthetic_amode(&mut self, arg0: VCodeConstant) -> SyntheticAmode;
312
    fn preg_rbp(&mut self) -> PReg;
313
    fn preg_rsp(&mut self) -> PReg;
314
    fn preg_pinned(&mut self) -> PReg;
315
    fn libcall_1(&mut self, arg0: &LibCall, arg1: Reg) -> Reg;
316
    fn libcall_3(&mut self, arg0: &LibCall, arg1: Reg, arg2: Reg, arg3: Reg) -> Reg;
317
    fn ishl_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
318
    fn ishl_i8x16_mask_table(&mut self) -> SyntheticAmode;
319
    fn ushr_i8x16_mask_for_const(&mut self, arg0: u32) -> SyntheticAmode;
320
    fn ushr_i8x16_mask_table(&mut self) -> SyntheticAmode;
321
    fn vconst_all_ones_or_all_zeros(&mut self, arg0: Constant) -> Option<()>;
322
    fn sse_insertps_lane_imm(&mut self, arg0: u8) -> u8;
323
    fn popcount_4bit_table(&mut self) -> VCodeConstant;
324
    fn popcount_low_mask(&mut self) -> VCodeConstant;
325
    fn pblendw_imm(&mut self, arg0: Immediate) -> Option<u8>;
326
    fn palignr_imm_from_immediate(&mut self, arg0: Immediate) -> Option<u8>;
327
    fn pshuflw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
328
    fn pshuflw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
329
    fn pshufhw_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
330
    fn pshufhw_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
331
    fn pshufd_lhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
332
    fn pshufd_rhs_imm(&mut self, arg0: Immediate) -> Option<u8>;
333
    fn shufps_imm(&mut self, arg0: Immediate) -> Option<u8>;
334
    fn shufps_rev_imm(&mut self, arg0: Immediate) -> Option<u8>;
335
    fn unpack_value_array_2(&mut self, arg0: &ValueArray2) -> (Value, Value);
336
    fn pack_value_array_2(&mut self, arg0: Value, arg1: Value) -> ValueArray2;
337
    fn unpack_value_array_3(&mut self, arg0: &ValueArray3) -> (Value, Value, Value);
338
    fn pack_value_array_3(&mut self, arg0: Value, arg1: Value, arg2: Value) -> ValueArray3;
339
    fn unpack_block_array_2(&mut self, arg0: &BlockArray2) -> (BlockCall, BlockCall);
340
    fn pack_block_array_2(&mut self, arg0: BlockCall, arg1: BlockCall) -> BlockArray2;
341
}
342

            
343
pub trait ContextIter {
344
    type Context;
345
    type Output;
346
    fn next(&mut self, ctx: &mut Self::Context) -> Option<Self::Output>;
347
}
348

            
349
pub struct ContextIterWrapper<Item, I: Iterator<Item = Item>, C: Context> {
350
    iter: I,
351
    _ctx: PhantomData<C>,
352
}
353
impl<Item, I: Iterator<Item = Item>, C: Context> From<I> for ContextIterWrapper<Item, I, C> {
354
    fn from(iter: I) -> Self {
355
        Self {
356
            iter,
357
            _ctx: PhantomData,
358
        }
359
    }
360
}
361
impl<Item, I: Iterator<Item = Item>, C: Context> ContextIter for ContextIterWrapper<Item, I, C> {
362
    type Context = C;
363
    type Output = Item;
364
    fn next(&mut self, _ctx: &mut Self::Context) -> Option<Self::Output> {
365
        self.iter.next()
366
    }
367
}
368

            
369
/// Internal type SideEffectNoResult: defined at src/prelude_lower.isle line 282.
370
#[derive(Clone, Debug)]
371
pub enum SideEffectNoResult {
372
    Inst {
373
        inst: MInst,
374
    },
375
    Inst2 {
376
        inst1: MInst,
377
        inst2: MInst,
378
    },
379
    Inst3 {
380
        inst1: MInst,
381
        inst2: MInst,
382
        inst3: MInst,
383
    },
384
}
385

            
386
/// Internal type ProducesFlags: defined at src/prelude_lower.isle line 324.
387
#[derive(Clone, Debug)]
388
pub enum ProducesFlags {
389
    AlreadyExistingFlags,
390
    ProducesFlagsSideEffect { inst: MInst },
391
    ProducesFlagsTwiceSideEffect { inst1: MInst, inst2: MInst },
392
    ProducesFlagsReturnsReg { inst: MInst, result: Reg },
393
    ProducesFlagsReturnsResultWithConsumer { inst: MInst, result: Reg },
394
}
395

            
396
/// Internal type ConsumesFlags: defined at src/prelude_lower.isle line 346.
397
#[derive(Clone, Debug)]
398
pub enum ConsumesFlags {
399
    ConsumesFlagsSideEffect {
400
        inst: MInst,
401
    },
402
    ConsumesFlagsSideEffect2 {
403
        inst1: MInst,
404
        inst2: MInst,
405
    },
406
    ConsumesFlagsReturnsResultWithProducer {
407
        inst: MInst,
408
        result: Reg,
409
    },
410
    ConsumesFlagsReturnsReg {
411
        inst: MInst,
412
        result: Reg,
413
    },
414
    ConsumesFlagsTwiceReturnsValueRegs {
415
        inst1: MInst,
416
        inst2: MInst,
417
        result: ValueRegs,
418
    },
419
    ConsumesFlagsFourTimesReturnsValueRegs {
420
        inst1: MInst,
421
        inst2: MInst,
422
        inst3: MInst,
423
        inst4: MInst,
424
        result: ValueRegs,
425
    },
426
}
427

            
428
/// Internal type MInst: defined at src/isa/x64/inst.isle line 8.
429
#[derive(Clone)]
430
pub enum MInst {
431
    Nop {
432
        len: u8,
433
    },
434
    AluRmiR {
435
        size: OperandSize,
436
        op: AluRmiROpcode,
437
        src1: Gpr,
438
        src2: GprMemImm,
439
        dst: WritableGpr,
440
    },
441
    AluRM {
442
        size: OperandSize,
443
        op: AluRmiROpcode,
444
        src1_dst: SyntheticAmode,
445
        src2: Gpr,
446
    },
447
    AluRmRVex {
448
        size: OperandSize,
449
        op: AluRmROpcode,
450
        src1: Gpr,
451
        src2: Gpr,
452
        dst: WritableGpr,
453
    },
454
    AluConstOp {
455
        op: AluRmiROpcode,
456
        size: OperandSize,
457
        dst: WritableGpr,
458
    },
459
    UnaryRmR {
460
        size: OperandSize,
461
        op: UnaryRmROpcode,
462
        src: GprMem,
463
        dst: WritableGpr,
464
    },
465
    Not {
466
        size: OperandSize,
467
        src: Gpr,
468
        dst: WritableGpr,
469
    },
470
    Neg {
471
        size: OperandSize,
472
        src: Gpr,
473
        dst: WritableGpr,
474
    },
475
    Div {
476
        size: OperandSize,
477
        sign: DivSignedness,
478
        trap: TrapCode,
479
        divisor: GprMem,
480
        dividend_lo: Gpr,
481
        dividend_hi: Gpr,
482
        dst_quotient: WritableGpr,
483
        dst_remainder: WritableGpr,
484
    },
485
    Div8 {
486
        sign: DivSignedness,
487
        trap: TrapCode,
488
        divisor: GprMem,
489
        dividend: Gpr,
490
        dst: WritableGpr,
491
    },
492
    MulHi {
493
        size: OperandSize,
494
        signed: bool,
495
        src1: Gpr,
496
        src2: GprMem,
497
        dst_lo: WritableGpr,
498
        dst_hi: WritableGpr,
499
    },
500
    CheckedSRemSeq {
501
        size: OperandSize,
502
        dividend_lo: Gpr,
503
        dividend_hi: Gpr,
504
        divisor: Gpr,
505
        dst_quotient: WritableGpr,
506
        dst_remainder: WritableGpr,
507
    },
508
    CheckedSRemSeq8 {
509
        dividend: Gpr,
510
        divisor: Gpr,
511
        dst: WritableGpr,
512
    },
513
    SignExtendData {
514
        size: OperandSize,
515
        src: Gpr,
516
        dst: WritableGpr,
517
    },
518
    Imm {
519
        dst_size: OperandSize,
520
        simm64: u64,
521
        dst: WritableGpr,
522
    },
523
    MovRR {
524
        size: OperandSize,
525
        src: Gpr,
526
        dst: WritableGpr,
527
    },
528
    MovFromPReg {
529
        src: PReg,
530
        dst: WritableGpr,
531
    },
532
    MovToPReg {
533
        src: Gpr,
534
        dst: PReg,
535
    },
536
    MovzxRmR {
537
        ext_mode: ExtMode,
538
        src: GprMem,
539
        dst: WritableGpr,
540
    },
541
    Mov64MR {
542
        src: SyntheticAmode,
543
        dst: WritableGpr,
544
    },
545
    LoadEffectiveAddress {
546
        addr: SyntheticAmode,
547
        dst: WritableGpr,
548
        size: OperandSize,
549
    },
550
    MovsxRmR {
551
        ext_mode: ExtMode,
552
        src: GprMem,
553
        dst: WritableGpr,
554
    },
555
    MovImmM {
556
        size: OperandSize,
557
        simm64: u64,
558
        dst: SyntheticAmode,
559
    },
560
    MovRM {
561
        size: OperandSize,
562
        src: Gpr,
563
        dst: SyntheticAmode,
564
    },
565
    ShiftR {
566
        size: OperandSize,
567
        kind: ShiftKind,
568
        src: Gpr,
569
        num_bits: Imm8Gpr,
570
        dst: WritableGpr,
571
    },
572
    XmmRmiReg {
573
        opcode: SseOpcode,
574
        src1: Xmm,
575
        src2: XmmMemAlignedImm,
576
        dst: WritableXmm,
577
    },
578
    CmpRmiR {
579
        size: OperandSize,
580
        opcode: CmpOpcode,
581
        src: GprMemImm,
582
        dst: Gpr,
583
    },
584
    Setcc {
585
        cc: CC,
586
        dst: WritableGpr,
587
    },
588
    Bswap {
589
        size: OperandSize,
590
        src: Gpr,
591
        dst: WritableGpr,
592
    },
593
    Cmove {
594
        size: OperandSize,
595
        cc: CC,
596
        consequent: GprMem,
597
        alternative: Gpr,
598
        dst: WritableGpr,
599
    },
600
    XmmCmove {
601
        ty: Type,
602
        cc: CC,
603
        consequent: XmmMemAligned,
604
        alternative: Xmm,
605
        dst: WritableXmm,
606
    },
607
    Push64 {
608
        src: GprMemImm,
609
    },
610
    Pop64 {
611
        dst: WritableGpr,
612
    },
613
    StackProbeLoop {
614
        tmp: WritableReg,
615
        frame_size: u32,
616
        guard_size: u32,
617
    },
618
    XmmRmR {
619
        op: SseOpcode,
620
        src1: Xmm,
621
        src2: XmmMemAligned,
622
        dst: WritableXmm,
623
    },
624
    XmmRmRUnaligned {
625
        op: SseOpcode,
626
        src1: Xmm,
627
        src2: XmmMem,
628
        dst: WritableXmm,
629
    },
630
    XmmRmRBlend {
631
        op: SseOpcode,
632
        src1: Xmm,
633
        src2: XmmMemAligned,
634
        mask: Xmm,
635
        dst: WritableXmm,
636
    },
637
    XmmRmiRVex {
638
        op: AvxOpcode,
639
        src1: Xmm,
640
        src2: XmmMemImm,
641
        dst: WritableXmm,
642
    },
643
    XmmRmRImmVex {
644
        op: AvxOpcode,
645
        src1: Xmm,
646
        src2: XmmMem,
647
        dst: WritableXmm,
648
        imm: u8,
649
    },
650
    XmmVexPinsr {
651
        op: AvxOpcode,
652
        src1: Xmm,
653
        src2: GprMem,
654
        dst: WritableXmm,
655
        imm: u8,
656
    },
657
    XmmRmRVex3 {
658
        op: AvxOpcode,
659
        src1: Xmm,
660
        src2: Xmm,
661
        src3: XmmMem,
662
        dst: WritableXmm,
663
    },
664
    XmmRmRBlendVex {
665
        op: AvxOpcode,
666
        src1: Xmm,
667
        src2: XmmMem,
668
        mask: Xmm,
669
        dst: WritableXmm,
670
    },
671
    XmmUnaryRmRVex {
672
        op: AvxOpcode,
673
        src: XmmMem,
674
        dst: WritableXmm,
675
    },
676
    XmmUnaryRmRImmVex {
677
        op: AvxOpcode,
678
        src: XmmMem,
679
        dst: WritableXmm,
680
        imm: u8,
681
    },
682
    XmmMovRMVex {
683
        op: AvxOpcode,
684
        src: Xmm,
685
        dst: SyntheticAmode,
686
    },
687
    XmmMovRMImmVex {
688
        op: AvxOpcode,
689
        src: Xmm,
690
        dst: SyntheticAmode,
691
        imm: u8,
692
    },
693
    XmmToGprImmVex {
694
        op: AvxOpcode,
695
        src: Xmm,
696
        dst: WritableGpr,
697
        imm: u8,
698
    },
699
    GprToXmmVex {
700
        op: AvxOpcode,
701
        src: GprMem,
702
        dst: WritableXmm,
703
        src_size: OperandSize,
704
    },
705
    XmmToGprVex {
706
        op: AvxOpcode,
707
        src: Xmm,
708
        dst: WritableGpr,
709
        dst_size: OperandSize,
710
    },
711
    XmmRmREvex {
712
        op: Avx512Opcode,
713
        src1: XmmMem,
714
        src2: Xmm,
715
        dst: WritableXmm,
716
    },
717
    XmmRmREvex3 {
718
        op: Avx512Opcode,
719
        src1: XmmMem,
720
        src2: Xmm,
721
        src3: Xmm,
722
        dst: WritableXmm,
723
    },
724
    XmmUnaryRmR {
725
        op: SseOpcode,
726
        src: XmmMemAligned,
727
        dst: WritableXmm,
728
    },
729
    XmmUnaryRmRUnaligned {
730
        op: SseOpcode,
731
        src: XmmMem,
732
        dst: WritableXmm,
733
    },
734
    XmmUnaryRmRImm {
735
        op: SseOpcode,
736
        src: XmmMemAligned,
737
        imm: u8,
738
        dst: WritableXmm,
739
    },
740
    XmmUnaryRmREvex {
741
        op: Avx512Opcode,
742
        src: XmmMem,
743
        dst: WritableXmm,
744
    },
745
    XmmMovRM {
746
        op: SseOpcode,
747
        src: Xmm,
748
        dst: SyntheticAmode,
749
    },
750
    XmmMovRMImm {
751
        op: SseOpcode,
752
        src: Xmm,
753
        dst: SyntheticAmode,
754
        imm: u8,
755
    },
756
    XmmToGpr {
757
        op: SseOpcode,
758
        src: Xmm,
759
        dst: WritableGpr,
760
        dst_size: OperandSize,
761
    },
762
    XmmToGprImm {
763
        op: SseOpcode,
764
        src: Xmm,
765
        dst: WritableGpr,
766
        imm: u8,
767
    },
768
    GprToXmm {
769
        op: SseOpcode,
770
        src: GprMem,
771
        dst: WritableXmm,
772
        src_size: OperandSize,
773
    },
774
    CvtUint64ToFloatSeq {
775
        dst_size: OperandSize,
776
        src: Gpr,
777
        dst: WritableXmm,
778
        tmp_gpr1: WritableGpr,
779
        tmp_gpr2: WritableGpr,
780
    },
781
    CvtFloatToSintSeq {
782
        dst_size: OperandSize,
783
        src_size: OperandSize,
784
        is_saturating: bool,
785
        src: Xmm,
786
        dst: WritableGpr,
787
        tmp_gpr: WritableGpr,
788
        tmp_xmm: WritableXmm,
789
    },
790
    CvtFloatToUintSeq {
791
        dst_size: OperandSize,
792
        src_size: OperandSize,
793
        is_saturating: bool,
794
        src: Xmm,
795
        dst: WritableGpr,
796
        tmp_gpr: WritableGpr,
797
        tmp_xmm: WritableXmm,
798
        tmp_xmm2: WritableXmm,
799
    },
800
    XmmMinMaxSeq {
801
        size: OperandSize,
802
        is_min: bool,
803
        lhs: Xmm,
804
        rhs: Xmm,
805
        dst: WritableXmm,
806
    },
807
    XmmCmpRmR {
808
        op: SseOpcode,
809
        src: XmmMemAligned,
810
        dst: Xmm,
811
    },
812
    XmmRmRImm {
813
        op: SseOpcode,
814
        src1: Reg,
815
        src2: RegMem,
816
        dst: WritableReg,
817
        imm: u8,
818
        size: OperandSize,
819
    },
820
    CallKnown {
821
        dest: ExternalName,
822
        info: BoxCallInfo,
823
    },
824
    CallUnknown {
825
        dest: RegMem,
826
        info: BoxCallInfo,
827
    },
828
    Args {
829
        args: VecArgPair,
830
    },
831
    Ret {
832
        rets: VecRetPair,
833
    },
834
    JmpKnown {
835
        dst: MachLabel,
836
    },
837
    JmpIf {
838
        cc: CC,
839
        taken: MachLabel,
840
    },
841
    JmpCond {
842
        cc: CC,
843
        taken: MachLabel,
844
        not_taken: MachLabel,
845
    },
846
    JmpTableSeq {
847
        idx: Reg,
848
        tmp1: WritableReg,
849
        tmp2: WritableReg,
850
        default_target: MachLabel,
851
        targets: BoxVecMachLabel,
852
    },
853
    JmpUnknown {
854
        target: RegMem,
855
    },
856
    TrapIf {
857
        cc: CC,
858
        trap_code: TrapCode,
859
    },
860
    TrapIfAnd {
861
        cc1: CC,
862
        cc2: CC,
863
        trap_code: TrapCode,
864
    },
865
    TrapIfOr {
866
        cc1: CC,
867
        cc2: CC,
868
        trap_code: TrapCode,
869
    },
870
    Hlt,
871
    Ud2 {
872
        trap_code: TrapCode,
873
    },
874
    LoadExtName {
875
        dst: WritableReg,
876
        name: BoxExternalName,
877
        offset: i64,
878
    },
879
    LockCmpxchg {
880
        ty: Type,
881
        replacement: Reg,
882
        expected: Reg,
883
        mem: SyntheticAmode,
884
        dst_old: WritableReg,
885
    },
886
    AtomicRmwSeq {
887
        ty: Type,
888
        op: MachAtomicRmwOp,
889
        mem: SyntheticAmode,
890
        operand: Reg,
891
        temp: WritableReg,
892
        dst_old: WritableReg,
893
    },
894
    Fence {
895
        kind: FenceKind,
896
    },
897
    VirtualSPOffsetAdj {
898
        offset: i64,
899
    },
900
    XmmUninitializedValue {
901
        dst: WritableXmm,
902
    },
903
    ElfTlsGetAddr {
904
        symbol: ExternalName,
905
        dst: WritableGpr,
906
    },
907
    MachOTlsGetAddr {
908
        symbol: ExternalName,
909
        dst: WritableGpr,
910
    },
911
    CoffTlsGetAddr {
912
        symbol: ExternalName,
913
        dst: WritableGpr,
914
        tmp: WritableGpr,
915
    },
916
    Unwind {
917
        inst: UnwindInst,
918
    },
919
    DummyUse {
920
        reg: Reg,
921
    },
922
}
923

            
924
/// Internal type DivSignedness: defined at src/isa/x64/inst.isle line 663.
925
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
926
pub enum DivSignedness {
927
    Signed,
928
    Unsigned,
929
}
930

            
931
/// Internal type Amode: defined at src/isa/x64/inst.isle line 971.
932
#[derive(Clone, Debug)]
933
pub enum Amode {
934
    ImmReg {
935
        simm32: u32,
936
        base: Reg,
937
        flags: MemFlags,
938
    },
939
    ImmRegRegShift {
940
        simm32: u32,
941
        base: Gpr,
942
        index: Gpr,
943
        shift: u8,
944
        flags: MemFlags,
945
    },
946
    RipRelative {
947
        target: MachLabel,
948
    },
949
}
950

            
951
/// Internal type AvxOpcode: defined at src/isa/x64/inst.isle line 1120.
952
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
953
pub enum AvxOpcode {
954
    Vfmadd213ss,
955
    Vfmadd213sd,
956
    Vfmadd213ps,
957
    Vfmadd213pd,
958
    Vfmadd132ss,
959
    Vfmadd132sd,
960
    Vfmadd132ps,
961
    Vfmadd132pd,
962
    Vfnmadd213ss,
963
    Vfnmadd213sd,
964
    Vfnmadd213ps,
965
    Vfnmadd213pd,
966
    Vfnmadd132ss,
967
    Vfnmadd132sd,
968
    Vfnmadd132ps,
969
    Vfnmadd132pd,
970
    Vcmpps,
971
    Vcmppd,
972
    Vpsrlw,
973
    Vpsrld,
974
    Vpsrlq,
975
    Vpaddb,
976
    Vpaddw,
977
    Vpaddd,
978
    Vpaddq,
979
    Vpaddsb,
980
    Vpaddsw,
981
    Vpaddusb,
982
    Vpaddusw,
983
    Vpsubb,
984
    Vpsubw,
985
    Vpsubd,
986
    Vpsubq,
987
    Vpsubsb,
988
    Vpsubsw,
989
    Vpsubusb,
990
    Vpsubusw,
991
    Vpavgb,
992
    Vpavgw,
993
    Vpand,
994
    Vandps,
995
    Vandpd,
996
    Vpor,
997
    Vorps,
998
    Vorpd,
999
    Vpxor,
    Vxorps,
    Vxorpd,
    Vpmullw,
    Vpmulld,
    Vpmulhw,
    Vpmulhd,
    Vpmulhrsw,
    Vpmulhuw,
    Vpmuldq,
    Vpmuludq,
    Vpunpckhwd,
    Vpunpcklwd,
    Vunpcklps,
    Vandnps,
    Vandnpd,
    Vpandn,
    Vaddps,
    Vaddpd,
    Vsubps,
    Vsubpd,
    Vmulps,
    Vmulpd,
    Vdivps,
    Vdivpd,
    Vpcmpeqb,
    Vpcmpeqw,
    Vpcmpeqd,
    Vpcmpeqq,
    Vpcmpgtb,
    Vpcmpgtw,
    Vpcmpgtd,
    Vpcmpgtq,
    Vminps,
    Vminpd,
    Vmaxps,
    Vmaxpd,
    Vblendvpd,
    Vblendvps,
    Vpblendvb,
    Vmovlhps,
    Vpmaxsb,
    Vpmaxsw,
    Vpmaxsd,
    Vpminsb,
    Vpminsw,
    Vpminsd,
    Vpmaxub,
    Vpmaxuw,
    Vpmaxud,
    Vpminub,
    Vpminuw,
    Vpminud,
    Vpunpcklbw,
    Vpunpckhbw,
    Vpacksswb,
    Vpackssdw,
    Vpackuswb,
    Vpackusdw,
    Vpalignr,
    Vpinsrb,
    Vpinsrw,
    Vpinsrd,
    Vpinsrq,
    Vpmaddwd,
    Vpmaddubsw,
    Vinsertps,
    Vpshufb,
    Vshufps,
    Vpsllw,
    Vpslld,
    Vpsllq,
    Vpsraw,
    Vpsrad,
    Vpmovsxbw,
    Vpmovzxbw,
    Vpmovsxwd,
    Vpmovzxwd,
    Vpmovsxdq,
    Vpmovzxdq,
    Vaddss,
    Vaddsd,
    Vmulss,
    Vmulsd,
    Vsubss,
    Vsubsd,
    Vdivss,
    Vdivsd,
    Vpabsb,
    Vpabsw,
    Vpabsd,
    Vminss,
    Vminsd,
    Vmaxss,
    Vmaxsd,
    Vsqrtps,
    Vsqrtpd,
    Vroundps,
    Vroundpd,
    Vcvtdq2pd,
    Vcvtdq2ps,
    Vcvtpd2ps,
    Vcvtps2pd,
    Vcvttpd2dq,
    Vcvttps2dq,
    Vphaddw,
    Vphaddd,
    Vpunpckhdq,
    Vpunpckldq,
    Vpunpckhqdq,
    Vpunpcklqdq,
    Vpshuflw,
    Vpshufhw,
    Vpshufd,
    Vmovss,
    Vmovsd,
    Vmovups,
    Vmovupd,
    Vmovdqu,
    Vpextrb,
    Vpextrw,
    Vpextrd,
    Vpextrq,
    Vpblendw,
    Vmovddup,
    Vpbroadcastb,
    Vpbroadcastw,
    Vpbroadcastd,
    Vbroadcastss,
    Vmovd,
    Vmovq,
    Vmovmskps,
    Vmovmskpd,
    Vpmovmskb,
    Vcvtsi2ss,
    Vcvtsi2sd,
    Vcvtss2sd,
    Vcvtsd2ss,
    Vsqrtss,
    Vsqrtsd,
    Vroundss,
    Vroundsd,
}
/// Internal type RegisterClass: defined at src/isa/x64/inst.isle line 1585.
#[derive(Clone, Debug)]
pub enum RegisterClass {
    Gpr { single_register: bool },
    Xmm,
}
/// Internal type ExtendKind: defined at src/isa/x64/inst.isle line 1726.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum ExtendKind {
    Sign,
    Zero,
}
/// Internal type IcmpCondResult: defined at src/isa/x64/inst.isle line 4359.
#[derive(Clone, Debug)]
pub enum IcmpCondResult {
    Condition { producer: ProducesFlags, cc: CC },
}
/// Internal type FcmpCondResult: defined at src/isa/x64/inst.isle line 4472.
#[derive(Clone, Debug)]
pub enum FcmpCondResult {
    Condition {
        producer: ProducesFlags,
        cc: CC,
    },
    AndCondition {
        producer: ProducesFlags,
        cc1: CC,
        cc2: CC,
    },
    OrCondition {
        producer: ProducesFlags,
        cc1: CC,
        cc2: CC,
    },
}
// Generated as internal constructor for term output_reg.
pub fn constructor_output_reg<C: Context>(ctx: &mut C, arg0: Reg) -> InstOutput {
    let v1 = C::value_reg(ctx, arg0);
    let v2 = C::output(ctx, v1);
    // Rule at src/prelude_lower.isle line 55.
    return v2;
}
// Generated as internal constructor for term output_value.
pub fn constructor_output_value<C: Context>(ctx: &mut C, arg0: Value) -> InstOutput {
    let v1 = C::put_in_regs(ctx, arg0);
    let v2 = C::output(ctx, v1);
    // Rule at src/prelude_lower.isle line 59.
    return v2;
}
// Generated as internal constructor for term temp_reg.
pub fn constructor_temp_reg<C: Context>(ctx: &mut C, arg0: Type) -> Reg {
    let v1 = C::temp_writable_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/prelude_lower.isle line 79.
    return v2;
}
// Generated as internal constructor for term value_regs_range.
pub fn constructor_value_regs_range<C: Context>(ctx: &mut C, arg0: ValueRegs) -> Range {
    let v2 = C::value_regs_len(ctx, arg0);
    let v3 = C::range(ctx, 0x0, v2);
    // Rule at src/prelude_lower.isle line 128.
    return v3;
}
// Generated as internal constructor for term lo_reg.
pub fn constructor_lo_reg<C: Context>(ctx: &mut C, arg0: Value) -> Reg {
    let v1 = C::put_in_regs(ctx, arg0);
    let v3 = C::value_regs_get(ctx, v1, 0x0);
    // Rule at src/prelude_lower.isle line 139.
    return v3;
}
// Generated as internal constructor for term emit_side_effect.
pub fn constructor_emit_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> Unit {
    match arg0 {
        &SideEffectNoResult::Inst { inst: ref v1 } => {
            let v2 = C::emit(ctx, v1);
            // Rule at src/prelude_lower.isle line 292.
            return v2;
        }
        &SideEffectNoResult::Inst2 {
            inst1: ref v3,
            inst2: ref v4,
        } => {
            let v5 = C::emit(ctx, v3);
            let v6 = C::emit(ctx, v4);
            // Rule at src/prelude_lower.isle line 294.
            return v6;
        }
        &SideEffectNoResult::Inst3 {
            inst1: ref v7,
            inst2: ref v8,
            inst3: ref v9,
        } => {
            let v10 = C::emit(ctx, v7);
            let v11 = C::emit(ctx, v8);
            let v12 = C::emit(ctx, v9);
            // Rule at src/prelude_lower.isle line 297.
            return v12;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "emit_side_effect", "src/prelude_lower.isle line 291"
    )
}
// Generated as internal constructor for term side_effect.
pub fn constructor_side_effect<C: Context>(ctx: &mut C, arg0: &SideEffectNoResult) -> InstOutput {
    let v1 = constructor_emit_side_effect(ctx, arg0);
    let v2 = C::output_none(ctx);
    // Rule at src/prelude_lower.isle line 305.
    return v2;
}
// Generated as internal constructor for term side_effect_concat.
pub fn constructor_side_effect_concat<C: Context>(
    ctx: &mut C,
    arg0: &SideEffectNoResult,
    arg1: &SideEffectNoResult,
) -> SideEffectNoResult {
    match arg0 {
        &SideEffectNoResult::Inst { inst: ref v1 } => {
            match arg1 {
                &SideEffectNoResult::Inst { inst: ref v3 } => {
                    let v4 = SideEffectNoResult::Inst2 {
                        inst1: v1.clone(),
                        inst2: v3.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 310.
                    return v4;
                }
                &SideEffectNoResult::Inst2 {
                    inst1: ref v5,
                    inst2: ref v6,
                } => {
                    let v7 = SideEffectNoResult::Inst3 {
                        inst1: v1.clone(),
                        inst2: v5.clone(),
                        inst3: v6.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 312.
                    return v7;
                }
                _ => {}
            }
        }
        &SideEffectNoResult::Inst2 {
            inst1: ref v8,
            inst2: ref v9,
        } => {
            if let &SideEffectNoResult::Inst { inst: ref v3 } = arg1 {
                let v10 = SideEffectNoResult::Inst3 {
                    inst1: v8.clone(),
                    inst2: v9.clone(),
                    inst3: v3.clone(),
                };
                // Rule at src/prelude_lower.isle line 314.
                return v10;
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "side_effect_concat", "src/prelude_lower.isle line 309"
    )
}
// Generated as internal constructor for term produces_flags_append.
pub fn constructor_produces_flags_append<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &MInst,
) -> ProducesFlags {
    if let &ProducesFlags::ProducesFlagsSideEffect { inst: ref v1 } = arg0 {
        let v3 = ProducesFlags::ProducesFlagsTwiceSideEffect {
            inst1: v1.clone(),
            inst2: arg1.clone(),
        };
        // Rule at src/prelude_lower.isle line 339.
        return v3;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "produces_flags_append", "src/prelude_lower.isle line 338"
    )
}
// Generated as internal constructor for term produces_flags_get_reg.
pub fn constructor_produces_flags_get_reg<C: Context>(ctx: &mut C, arg0: &ProducesFlags) -> Reg {
    match arg0 {
        &ProducesFlags::ProducesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            // Rule at src/prelude_lower.isle line 364.
            return v2;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v3,
            result: v4,
        } => {
            // Rule at src/prelude_lower.isle line 365.
            return v4;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "produces_flags_get_reg", "src/prelude_lower.isle line 363"
    )
}
// Generated as internal constructor for term produces_flags_ignore.
pub fn constructor_produces_flags_ignore<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
) -> ProducesFlags {
    match arg0 {
        &ProducesFlags::ProducesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            let v3 = ProducesFlags::ProducesFlagsSideEffect { inst: v1.clone() };
            // Rule at src/prelude_lower.isle line 370.
            return v3;
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v4,
            result: v5,
        } => {
            let v6 = ProducesFlags::ProducesFlagsSideEffect { inst: v4.clone() };
            // Rule at src/prelude_lower.isle line 372.
            return v6;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "produces_flags_ignore", "src/prelude_lower.isle line 369"
    )
}
// Generated as internal constructor for term consumes_flags_concat.
pub fn constructor_consumes_flags_concat<C: Context>(
    ctx: &mut C,
    arg0: &ConsumesFlags,
    arg1: &ConsumesFlags,
) -> ConsumesFlags {
    match arg0 {
        &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v8 } => {
            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } = arg1 {
                let v10 = ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: v8.clone(),
                    inst2: v9.clone(),
                };
                // Rule at src/prelude_lower.isle line 385.
                return v10;
            }
        }
        &ConsumesFlags::ConsumesFlagsReturnsReg {
            inst: ref v1,
            result: v2,
        } => {
            if let &ConsumesFlags::ConsumesFlagsReturnsReg {
                inst: ref v4,
                result: v5,
            } = arg1
            {
                let v6 = C::value_regs(ctx, v2, v5);
                let v7 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: v1.clone(),
                    inst2: v4.clone(),
                    result: v6,
                };
                // Rule at src/prelude_lower.isle line 379.
                return v7;
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "consumes_flags_concat", "src/prelude_lower.isle line 378"
    )
}
// Generated as internal constructor for term with_flags.
pub fn constructor_with_flags<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> ValueRegs {
    match arg0 {
        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v12 } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsReturnsReg {
                    inst: ref v13,
                    result: v14,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v16 = C::emit(ctx, v13);
                    let v17 = C::value_reg(ctx, v14);
                    // Rule at src/prelude_lower.isle line 416.
                    return v17;
                }
                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: ref v18,
                    inst2: ref v19,
                    result: v20,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v21 = C::emit(ctx, v18);
                    let v22 = C::emit(ctx, v19);
                    // Rule at src/prelude_lower.isle line 422.
                    return v20;
                }
                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                    inst1: ref v23,
                    inst2: ref v24,
                    inst3: ref v25,
                    inst4: ref v26,
                    result: v27,
                } => {
                    let v15 = C::emit(ctx, v12);
                    let v28 = C::emit(ctx, v23);
                    let v29 = C::emit(ctx, v24);
                    let v30 = C::emit(ctx, v25);
                    let v31 = C::emit(ctx, v26);
                    // Rule at src/prelude_lower.isle line 434.
                    return v27;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsTwiceSideEffect {
            inst1: ref v32,
            inst2: ref v33,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsReturnsReg {
                    inst: ref v13,
                    result: v14,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v36 = C::emit(ctx, v13);
                    let v37 = C::value_reg(ctx, v14);
                    // Rule at src/prelude_lower.isle line 450.
                    return v37;
                }
                &ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                    inst1: ref v18,
                    inst2: ref v19,
                    result: v20,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v38 = C::emit(ctx, v18);
                    let v39 = C::emit(ctx, v19);
                    // Rule at src/prelude_lower.isle line 457.
                    return v20;
                }
                &ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                    inst1: ref v23,
                    inst2: ref v24,
                    inst3: ref v25,
                    inst4: ref v26,
                    result: v27,
                } => {
                    let v34 = C::emit(ctx, v32);
                    let v35 = C::emit(ctx, v33);
                    let v40 = C::emit(ctx, v23);
                    let v41 = C::emit(ctx, v24);
                    let v42 = C::emit(ctx, v25);
                    let v43 = C::emit(ctx, v26);
                    // Rule at src/prelude_lower.isle line 470.
                    return v27;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
            inst: ref v1,
            result: v2,
        } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v9 } => {
                    let v6 = C::emit(ctx, v1);
                    let v10 = C::emit(ctx, v9);
                    let v11 = C::value_reg(ctx, v2);
                    // Rule at src/prelude_lower.isle line 410.
                    return v11;
                }
                &ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
                    inst: ref v4,
                    result: v5,
                } => {
                    let v6 = C::emit(ctx, v1);
                    let v7 = C::emit(ctx, v4);
                    let v8 = C::value_regs(ctx, v2, v5);
                    // Rule at src/prelude_lower.isle line 402.
                    return v8;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "with_flags", "src/prelude_lower.isle line 400"
    )
}
// Generated as internal constructor for term with_flags_reg.
pub fn constructor_with_flags_reg<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> Reg {
    let v2 = constructor_with_flags(ctx, arg0, arg1);
    let v4 = C::value_regs_get(ctx, v2, 0x0);
    // Rule at src/prelude_lower.isle line 488.
    return v4;
}
// Generated as internal constructor for term flags_to_producesflags.
pub fn constructor_flags_to_producesflags<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {
    let v1 = C::mark_value_used(ctx, arg0);
    // Rule at src/prelude_lower.isle line 495.
    return ProducesFlags::AlreadyExistingFlags;
}
// Generated as internal constructor for term with_flags_side_effect.
pub fn constructor_with_flags_side_effect<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &ConsumesFlags,
) -> SideEffectNoResult {
    match arg0 {
        &ProducesFlags::AlreadyExistingFlags => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {
                    let v3 = SideEffectNoResult::Inst { inst: v2.clone() };
                    // Rule at src/prelude_lower.isle line 506.
                    return v3;
                }
                &ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: ref v4,
                    inst2: ref v5,
                } => {
                    let v6 = SideEffectNoResult::Inst2 {
                        inst1: v4.clone(),
                        inst2: v5.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 511.
                    return v6;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsSideEffect { inst: ref v7 } => {
            match arg1 {
                &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } => {
                    let v8 = SideEffectNoResult::Inst2 {
                        inst1: v7.clone(),
                        inst2: v2.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 516.
                    return v8;
                }
                &ConsumesFlags::ConsumesFlagsSideEffect2 {
                    inst1: ref v4,
                    inst2: ref v5,
                } => {
                    let v9 = SideEffectNoResult::Inst3 {
                        inst1: v7.clone(),
                        inst2: v4.clone(),
                        inst3: v5.clone(),
                    };
                    // Rule at src/prelude_lower.isle line 521.
                    return v9;
                }
                _ => {}
            }
        }
        &ProducesFlags::ProducesFlagsTwiceSideEffect {
            inst1: ref v10,
            inst2: ref v11,
        } => {
            if let &ConsumesFlags::ConsumesFlagsSideEffect { inst: ref v2 } = arg1 {
                let v12 = SideEffectNoResult::Inst3 {
                    inst1: v10.clone(),
                    inst2: v11.clone(),
                    inst3: v2.clone(),
                };
                // Rule at src/prelude_lower.isle line 526.
                return v12;
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "with_flags_side_effect", "src/prelude_lower.isle line 504"
    )
}
// Generated as internal constructor for term lower_return.
pub fn constructor_lower_return<C: Context>(
    ctx: &mut C,
    arg0: Range,
    arg1: ValueSlice,
) -> InstOutput {
    let v2 = C::gen_return(ctx, arg1);
    let v3 = C::output_none(ctx);
    // Rule at src/prelude_lower.isle line 715.
    return v3;
}
// Generated as internal constructor for term operand_size_bits.
pub fn constructor_operand_size_bits<C: Context>(ctx: &mut C, arg0: &OperandSize) -> u16 {
    match arg0 {
        &OperandSize::Size8 => {
            // Rule at src/isa/x64/inst.isle line 704.
            return 0x8;
        }
        &OperandSize::Size16 => {
            // Rule at src/isa/x64/inst.isle line 705.
            return 0x10;
        }
        &OperandSize::Size32 => {
            // Rule at src/isa/x64/inst.isle line 706.
            return 0x20;
        }
        &OperandSize::Size64 => {
            // Rule at src/isa/x64/inst.isle line 707.
            return 0x40;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "operand_size_bits", "src/isa/x64/inst.isle line 703"
    )
}
// Generated as internal constructor for term reg_mem_to_reg_mem_imm.
pub fn constructor_reg_mem_to_reg_mem_imm<C: Context>(ctx: &mut C, arg0: &RegMem) -> RegMemImm {
    match arg0 {
        &RegMem::Reg { reg: v1 } => {
            let v2 = RegMemImm::Reg { reg: v1 };
            // Rule at src/isa/x64/inst.isle line 945.
            return v2;
        }
        &RegMem::Mem { addr: ref v3 } => {
            let v4 = RegMemImm::Mem { addr: v3.clone() };
            // Rule at src/isa/x64/inst.isle line 947.
            return v4;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "reg_mem_to_reg_mem_imm", "src/isa/x64/inst.isle line 944"
    )
}
// Generated as internal constructor for term to_amode.
pub fn constructor_to_amode<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Offset32,
) -> Amode {
    let v6 = C::def_inst(ctx, arg1);
    if let Some(v7) = v6 {
        let v8 = &C::inst_data(ctx, v7);
        if let &InstructionData::Binary {
            opcode: ref v9,
            args: ref v10,
        } = v8
        {
            if let &Opcode::Iadd = v9 {
                let v11 = C::unpack_value_array_2(ctx, v10);
                let v14 = &constructor_to_amode_add(ctx, arg0, v11.0, v11.1, arg2);
                // Rule at src/isa/x64/inst.isle line 1009.
                return v14.clone();
            }
        }
    }
    let v4 = C::put_in_reg(ctx, arg1);
    let v3 = C::offset32_to_u32(ctx, arg2);
    let v5 = Amode::ImmReg {
        simm32: v3,
        base: v4,
        flags: arg0,
    };
    // Rule at src/isa/x64/inst.isle line 1004.
    return v5;
}
// Generated as internal constructor for term to_amode_add.
pub fn constructor_to_amode_add<C: Context>(
    ctx: &mut C,
    arg0: MemFlags,
    arg1: Value,
    arg2: Value,
    arg3: Offset32,
) -> Amode {
    let v30 = C::def_inst(ctx, arg1);
    if let Some(v31) = v30 {
        let v32 = &C::inst_data(ctx, v31);
        if let &InstructionData::UnaryImm {
            opcode: ref v71,
            imm: v72,
        } = v32
        {
            if let &Opcode::Iconst = v71 {
                let v73 = C::simm32(ctx, v72);
                if let Some(v74) = v73 {
                    let v4 = C::offset32_to_u32(ctx, arg3);
                    let v75 = C::s32_add_fallible(ctx, v4, v74);
                    if let Some(v76) = v75 {
                        let v77 = C::u32_to_offset32(ctx, v76);
                        let v78 = &constructor_to_amode(ctx, arg0, arg2, v77);
                        // Rule at src/isa/x64/inst.isle line 1048.
                        return v78.clone();
                    }
                }
            }
        }
    }
    let v9 = C::def_inst(ctx, arg2);
    if let Some(v10) = v9 {
        let v11 = &C::inst_data(ctx, v10);
        match v11 {
            &InstructionData::Binary {
                opcode: ref v12,
                args: ref v13,
            } => {
                if let &Opcode::Iadd = v12 {
                    let v14 = C::unpack_value_array_2(ctx, v13);
                    let v17 = C::def_inst(ctx, v14.1);
                    if let Some(v18) = v17 {
                        let v19 = &C::inst_data(ctx, v18);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v20,
                            imm: v21,
                        } = v19
                        {
                            if let &Opcode::Iconst = v20 {
                                let v57 = C::simm32(ctx, v21);
                                if let Some(v58) = v57 {
                                    let v4 = C::offset32_to_u32(ctx, arg3);
                                    let v59 = C::s32_add_fallible(ctx, v4, v58);
                                    if let Some(v60) = v59 {
                                        let v61 = C::u32_to_offset32(ctx, v60);
                                        let v62 =
                                            &constructor_to_amode_add(ctx, arg0, arg1, v14.0, v61);
                                        // Rule at src/isa/x64/inst.isle line 1042.
                                        return v62.clone();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            &InstructionData::UnaryImm {
                opcode: ref v63,
                imm: v64,
            } => {
                if let &Opcode::Iconst = v63 {
                    let v65 = C::simm32(ctx, v64);
                    if let Some(v66) = v65 {
                        let v4 = C::offset32_to_u32(ctx, arg3);
                        let v67 = C::s32_add_fallible(ctx, v4, v66);
                        if let Some(v68) = v67 {
                            let v69 = C::u32_to_offset32(ctx, v68);
                            let v70 = &constructor_to_amode(ctx, arg0, arg1, v69);
                            // Rule at src/isa/x64/inst.isle line 1045.
                            return v70.clone();
                        }
                    }
                }
            }
            _ => {}
        }
    }
    if let Some(v31) = v30 {
        let v32 = &C::inst_data(ctx, v31);
        if let &InstructionData::Binary {
            opcode: ref v33,
            args: ref v34,
        } = v32
        {
            match v33 {
                &Opcode::Iadd => {
                    let v35 = C::unpack_value_array_2(ctx, v34);
                    let v38 = C::def_inst(ctx, v35.1);
                    if let Some(v39) = v38 {
                        let v40 = &C::inst_data(ctx, v39);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v41,
                            imm: v42,
                        } = v40
                        {
                            if let &Opcode::Iconst = v41 {
                                let v51 = C::simm32(ctx, v42);
                                if let Some(v52) = v51 {
                                    let v4 = C::offset32_to_u32(ctx, arg3);
                                    let v53 = C::s32_add_fallible(ctx, v4, v52);
                                    if let Some(v54) = v53 {
                                        let v55 = C::u32_to_offset32(ctx, v54);
                                        let v56 =
                                            &constructor_to_amode_add(ctx, arg0, v35.0, arg2, v55);
                                        // Rule at src/isa/x64/inst.isle line 1039.
                                        return v56.clone();
                                    }
                                }
                            }
                        }
                    }
                }
                &Opcode::Ishl => {
                    let v35 = C::unpack_value_array_2(ctx, v34);
                    let v38 = C::def_inst(ctx, v35.1);
                    if let Some(v39) = v38 {
                        let v40 = &C::inst_data(ctx, v39);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v41,
                            imm: v42,
                        } = v40
                        {
                            if let &Opcode::Iconst = v41 {
                                let v43 = C::uimm8(ctx, v42);
                                if let Some(v44) = v43 {
                                    let v45 = C::u8_as_u32(ctx, v44);
                                    let v46 = C::u32_lteq(ctx, v45, 0x3);
                                    if let Some(v47) = v46 {
                                        let v48 = constructor_put_in_gpr(ctx, arg2);
                                        let v49 = constructor_put_in_gpr(ctx, v35.0);
                                        let v4 = C::offset32_to_u32(ctx, arg3);
                                        let v50 = Amode::ImmRegRegShift {
                                            simm32: v4,
                                            base: v48,
                                            index: v49,
                                            shift: v44,
                                            flags: arg0,
                                        };
                                        // Rule at src/isa/x64/inst.isle line 1026.
                                        return v50;
                                    }
                                }
                            }
                        }
                    }
                }
                _ => {}
            }
        }
    }
    if let Some(v10) = v9 {
        let v11 = &C::inst_data(ctx, v10);
        if let &InstructionData::Binary {
            opcode: ref v12,
            args: ref v13,
        } = v11
        {
            if let &Opcode::Ishl = v12 {
                let v14 = C::unpack_value_array_2(ctx, v13);
                let v17 = C::def_inst(ctx, v14.1);
                if let Some(v18) = v17 {
                    let v19 = &C::inst_data(ctx, v18);
                    if let &InstructionData::UnaryImm {
                        opcode: ref v20,
                        imm: v21,
                    } = v19
                    {
                        if let &Opcode::Iconst = v20 {
                            let v22 = C::uimm8(ctx, v21);
                            if let Some(v23) = v22 {
                                let v24 = C::u8_as_u32(ctx, v23);
                                let v26 = C::u32_lteq(ctx, v24, 0x3);
                                if let Some(v27) = v26 {
                                    let v5 = constructor_put_in_gpr(ctx, arg1);
                                    let v28 = constructor_put_in_gpr(ctx, v14.0);
                                    let v4 = C::offset32_to_u32(ctx, arg3);
                                    let v29 = Amode::ImmRegRegShift {
                                        simm32: v4,
                                        base: v5,
                                        index: v28,
                                        shift: v23,
                                        flags: arg0,
                                    };
                                    // Rule at src/isa/x64/inst.isle line 1023.
                                    return v29;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    let v5 = constructor_put_in_gpr(ctx, arg1);
    let v6 = constructor_put_in_gpr(ctx, arg2);
    let v4 = C::offset32_to_u32(ctx, arg3);
    let v8 = Amode::ImmRegRegShift {
        simm32: v4,
        base: v5,
        index: v6,
        shift: 0x0,
        flags: arg0,
    };
    // Rule at src/isa/x64/inst.isle line 1018.
    return v8;
}
// Generated as internal constructor for term put_masked_in_imm8_gpr.
pub fn constructor_put_masked_in_imm8_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Type,
) -> Imm8Gpr {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data(ctx, v2);
        if let &InstructionData::UnaryImm {
            opcode: ref v4,
            imm: v5,
        } = v3
        {
            if let &Opcode::Iconst = v4 {
                let v6 = C::u64_from_imm64(ctx, v5);
                let v8 = &C::const_to_type_masked_imm8(ctx, v6, arg1);
                // Rule at src/isa/x64/inst.isle line 1084.
                return v8.clone();
            }
        }
    }
    let v9 = C::fits_in_16(ctx, arg1);
    if let Some(v10) = v9 {
        let v12 = C::put_in_regs(ctx, arg0);
        let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);
        let v15 = C::shift_mask(ctx, v10);
        let v16 = RegMemImm::Imm { simm32: v15 };
        let v17 = &C::gpr_mem_imm_new(ctx, &v16);
        let v18 = constructor_x64_and(ctx, I64, v14, v17);
        let v19 = &C::gpr_to_imm8_gpr(ctx, v18);
        // Rule at src/isa/x64/inst.isle line 1086.
        return v19.clone();
    }
    let v12 = C::put_in_regs(ctx, arg0);
    let v14 = constructor_value_regs_get_gpr(ctx, v12, 0x0);
    let v20 = &C::gpr_to_imm8_gpr(ctx, v14);
    // Rule at src/isa/x64/inst.isle line 1088.
    return v20.clone();
}
// Generated as internal constructor for term reg_to_gpr_mem_imm.
pub fn constructor_reg_to_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Reg) -> GprMemImm {
    let v1 = C::gpr_new(ctx, arg0);
    let v2 = &C::gpr_to_gpr_mem_imm(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1493.
    return v2.clone();
}
// Generated as internal constructor for term put_in_gpr.
pub fn constructor_put_in_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::gpr_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1500.
    return v2;
}
// Generated as internal constructor for term put_in_gpr_mem.
pub fn constructor_put_in_gpr_mem<C: Context>(ctx: &mut C, arg0: Value) -> GprMem {
    let v1 = &C::put_in_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1507.
    return v2.clone();
}
// Generated as internal constructor for term put_in_gpr_mem_imm.
pub fn constructor_put_in_gpr_mem_imm<C: Context>(ctx: &mut C, arg0: Value) -> GprMemImm {
    let v1 = &C::put_in_reg_mem_imm(ctx, arg0);
    let v2 = &C::gpr_mem_imm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1514.
    return v2.clone();
}
// Generated as internal constructor for term put_in_xmm.
pub fn constructor_put_in_xmm<C: Context>(ctx: &mut C, arg0: Value) -> Xmm {
    let v1 = C::put_in_reg(ctx, arg0);
    let v2 = C::xmm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1521.
    return v2;
}
// Generated as internal constructor for term output_gpr.
pub fn constructor_output_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> InstOutput {
    let v1 = C::gpr_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1538.
    return v2;
}
// Generated as internal constructor for term value_gprs.
pub fn constructor_value_gprs<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> ValueRegs {
    let v2 = C::gpr_to_reg(ctx, arg0);
    let v3 = C::gpr_to_reg(ctx, arg1);
    let v4 = C::value_regs(ctx, v2, v3);
    // Rule at src/isa/x64/inst.isle line 1543.
    return v4;
}
// Generated as internal constructor for term output_xmm.
pub fn constructor_output_xmm<C: Context>(ctx: &mut C, arg0: Xmm) -> InstOutput {
    let v1 = C::xmm_to_reg(ctx, arg0);
    let v2 = constructor_output_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1548.
    return v2;
}
// Generated as internal constructor for term value_regs_get_gpr.
pub fn constructor_value_regs_get_gpr<C: Context>(
    ctx: &mut C,
    arg0: ValueRegs,
    arg1: usize,
) -> Gpr {
    let v2 = C::value_regs_get(ctx, arg0, arg1);
    let v3 = C::gpr_new(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 1555.
    return v3;
}
// Generated as internal constructor for term lo_gpr.
pub fn constructor_lo_gpr<C: Context>(ctx: &mut C, arg0: Value) -> Gpr {
    let v1 = constructor_lo_reg(ctx, arg0);
    let v2 = C::gpr_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1568.
    return v2;
}
// Generated as internal constructor for term sink_load_to_gpr_mem_imm.
pub fn constructor_sink_load_to_gpr_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> GprMemImm {
    let v1 = &constructor_sink_load_to_reg_mem_imm(ctx, arg0);
    let v2 = &C::gpr_mem_imm_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1703.
    return v2.clone();
}
// Generated as internal constructor for term sink_load_to_xmm_mem.
pub fn constructor_sink_load_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> XmmMem {
    let v1 = &constructor_sink_load_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1707.
    return v2.clone();
}
// Generated as internal constructor for term sink_load_to_reg_mem.
pub fn constructor_sink_load_to_reg_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> RegMem {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMem::Mem { addr: v1.clone() };
    // Rule at src/isa/x64/inst.isle line 1711.
    return v2;
}
// Generated as internal constructor for term sink_load_to_gpr_mem.
pub fn constructor_sink_load_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &SinkableLoad) -> GprMem {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMem::Mem { addr: v1.clone() };
    let v3 = &C::reg_mem_to_gpr_mem(ctx, &v2);
    // Rule at src/isa/x64/inst.isle line 1714.
    return v3.clone();
}
// Generated as internal constructor for term sink_load_to_reg_mem_imm.
pub fn constructor_sink_load_to_reg_mem_imm<C: Context>(
    ctx: &mut C,
    arg0: &SinkableLoad,
) -> RegMemImm {
    let v1 = &C::sink_load(ctx, arg0);
    let v2 = RegMemImm::Mem { addr: v1.clone() };
    // Rule at src/isa/x64/inst.isle line 1717.
    return v2;
}
// Generated as internal constructor for term extend_to_gpr.
pub fn constructor_extend_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: Value,
    arg1: Type,
    arg2: &ExtendKind,
) -> Gpr {
    let v1 = C::value_type(ctx, arg0);
    if v1 == arg1 {
        let v4 = constructor_put_in_gpr(ctx, arg0);
        // Rule at src/isa/x64/inst.isle line 1738.
        return v4;
    }
    if let &ExtendKind::Zero = arg2 {
        if v1 == I32 {
            if arg1 == I64 {
                let v5 = constructor_value32_zeros_upper32(ctx, arg0);
                if v5 == true {
                    let v4 = constructor_put_in_gpr(ctx, arg0);
                    // Rule at src/isa/x64/inst.isle line 1746.
                    return v4;
                }
            }
        }
        let v6 = C::def_inst(ctx, arg0);
        if let Some(v7) = v6 {
            let v8 = &C::inst_data(ctx, v7);
            if let &InstructionData::BinaryImm8 {
                opcode: ref v9,
                arg: v10,
                imm: v11,
            } = v8
            {
                if let &Opcode::Extractlane = v9 {
                    let v4 = constructor_put_in_gpr(ctx, arg0);
                    // Rule at src/isa/x64/inst.isle line 1762.
                    return v4;
                }
            }
        }
    }
    let v13 = &C::operand_size_of_type_32_64(ctx, arg1);
    let v14 = constructor_operand_size_bits(ctx, v13);
    let v12 = C::ty_bits_u16(ctx, v1);
    let v15 = &C::ext_mode(ctx, v12, v14);
    let v16 = &constructor_put_in_gpr_mem(ctx, arg0);
    let v17 = constructor_extend(ctx, arg2, arg1, v15, v16);
    // Rule at src/isa/x64/inst.isle line 1765.
    return v17;
}
// Generated as internal constructor for term extend.
pub fn constructor_extend<C: Context>(
    ctx: &mut C,
    arg0: &ExtendKind,
    arg1: Type,
    arg2: &ExtMode,
    arg3: &GprMem,
) -> Gpr {
    match arg0 {
        &ExtendKind::Sign => {
            let v5 = constructor_x64_movsx(ctx, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1785.
            return v5;
        }
        &ExtendKind::Zero => {
            let v4 = constructor_x64_movzx(ctx, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 1781.
            return v4;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "extend", "src/isa/x64/inst.isle line 1778"
    )
}
// Generated as internal constructor for term value32_zeros_upper32.
pub fn constructor_value32_zeros_upper32<C: Context>(ctx: &mut C, arg0: Value) -> bool {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data(ctx, v2);
        match v3 {
            &InstructionData::Binary {
                opcode: ref v4,
                args: ref v5,
            } => {
                match v4 {
                    &Opcode::Iadd => {
                        // Rule at src/isa/x64/inst.isle line 1792.
                        return true;
                    }
                    &Opcode::Isub => {
                        // Rule at src/isa/x64/inst.isle line 1793.
                        return true;
                    }
                    &Opcode::Imul => {
                        // Rule at src/isa/x64/inst.isle line 1794.
                        return true;
                    }
                    &Opcode::Band => {
                        // Rule at src/isa/x64/inst.isle line 1795.
                        return true;
                    }
                    &Opcode::Bor => {
                        // Rule at src/isa/x64/inst.isle line 1796.
                        return true;
                    }
                    &Opcode::Bxor => {
                        // Rule at src/isa/x64/inst.isle line 1797.
                        return true;
                    }
                    &Opcode::Ishl => {
                        // Rule at src/isa/x64/inst.isle line 1798.
                        return true;
                    }
                    &Opcode::Ushr => {
                        // Rule at src/isa/x64/inst.isle line 1799.
                        return true;
                    }
                    _ => {}
                }
            }
            &InstructionData::Load {
                opcode: ref v10,
                arg: v11,
                flags: v12,
                offset: v13,
            } => {
                if let &Opcode::Uload32 = v10 {
                    // Rule at src/isa/x64/inst.isle line 1800.
                    return true;
                }
            }
            _ => {}
        }
    }
    // Rule at src/isa/x64/inst.isle line 1801.
    return false;
}
// Generated as internal constructor for term vec_int_type.
pub fn constructor_vec_int_type<C: Context>(ctx: &mut C, arg0: Type) -> Type {
    let v1 = C::multi_lane(ctx, arg0);
    if let Some(v2) = v1 {
        match v2.0 {
            0x8 => {
                if v2.1 == 0x10 {
                    // Rule at src/isa/x64/inst.isle line 1807.
                    return I8X16;
                }
            }
            0x10 => {
                if v2.1 == 0x8 {
                    // Rule at src/isa/x64/inst.isle line 1808.
                    return I16X8;
                }
            }
            0x20 => {
                if v2.1 == 0x4 {
                    // Rule at src/isa/x64/inst.isle line 1809.
                    return I32X4;
                }
            }
            0x40 => {
                if v2.1 == 0x2 {
                    // Rule at src/isa/x64/inst.isle line 1810.
                    return I64X2;
                }
            }
            _ => {}
        }
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "vec_int_type", "src/isa/x64/inst.isle line 1806"
    )
}
// Generated as internal constructor for term x64_xor_vector.
pub fn constructor_x64_xor_vector<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1814.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1815.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_xorps(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1816.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_xorpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 1817.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pxor(ctx, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 1818.
        return v9;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_xor_vector", "src/isa/x64/inst.isle line 1813"
    )
}
// Generated as internal constructor for term vector_all_ones.
pub fn constructor_vector_all_ones<C: Context>(ctx: &mut C) -> Xmm {
    let v0 = constructor_xmm_uninit_value(ctx);
    let v1 = &C::xmm_to_xmm_mem(ctx, v0);
    let v2 = constructor_x64_pcmpeqd(ctx, v0, v1);
    // Rule at src/isa/x64/inst.isle line 1830.
    return v2;
}
// Generated as internal constructor for term xmm_uninit_value.
pub fn constructor_xmm_uninit_value<C: Context>(ctx: &mut C) -> Xmm {
    let v0 = C::temp_writable_xmm(ctx);
    let v1 = MInst::XmmUninitializedValue { dst: v0 };
    let v2 = C::emit(ctx, &v1);
    let v3 = C::writable_xmm_to_xmm(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 1836.
    return v3;
}
// Generated as internal constructor for term make_i64x2_from_lanes.
pub fn constructor_make_i64x2_from_lanes<C: Context>(
    ctx: &mut C,
    arg0: &GprMem,
    arg1: &GprMem,
) -> Xmm {
    let v2 = constructor_xmm_uninit_value(ctx);
    let v4 = constructor_x64_pinsrq(ctx, v2, arg0, 0x0);
    let v6 = constructor_x64_pinsrq(ctx, v4, arg1, 0x1);
    // Rule at src/isa/x64/inst.isle line 1843.
    return v6;
}
// Generated as internal constructor for term mov_rmi_to_xmm.
pub fn constructor_mov_rmi_to_xmm<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> XmmMemImm {
    match arg0 {
        &RegMemImm::Reg { reg: v4 } => {
            let v5 = &C::reg_to_gpr_mem(ctx, v4);
            let v6 = constructor_x64_movd_to_xmm(ctx, v5);
            let v7 = &C::xmm_to_xmm_mem_imm(ctx, v6);
            // Rule at src/isa/x64/inst.isle line 1853.
            return v7.clone();
        }
        &RegMemImm::Mem { addr: ref v1 } => {
            let v2 = &C::xmm_mem_imm_new(ctx, arg0);
            // Rule at src/isa/x64/inst.isle line 1851.
            return v2.clone();
        }
        &RegMemImm::Imm { simm32: v3 } => {
            let v2 = &C::xmm_mem_imm_new(ctx, arg0);
            // Rule at src/isa/x64/inst.isle line 1852.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "mov_rmi_to_xmm", "src/isa/x64/inst.isle line 1850"
    )
}
// Generated as internal constructor for term load_ext_name.
pub fn constructor_load_ext_name<C: Context>(ctx: &mut C, arg0: ExternalName, arg1: i64) -> Reg {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = C::writable_gpr_to_reg(ctx, v2);
    let v4 = C::box_external_name(ctx, arg0);
    let v5 = MInst::LoadExtName {
        dst: v3,
        name: v4,
        offset: arg1,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 1867.
    return v7;
}
// Generated as internal constructor for term x64_load.
pub fn constructor_x64_load<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: &ExtKind,
) -> Reg {
    match arg0 {
        I64 => {
            let v11 = C::temp_writable_gpr(ctx);
            let v12 = MInst::Mov64MR {
                src: arg1.clone(),
                dst: v11,
            };
            let v13 = C::emit(ctx, &v12);
            let v14 = constructor_writable_gpr_to_r_reg(ctx, v11);
            // Rule at src/isa/x64/inst.isle line 1879.
            return v14;
        }
        F32 => {
            let v15 = constructor_x64_movss_load(ctx, arg1);
            let v16 = C::xmm_to_reg(ctx, v15);
            // Rule at src/isa/x64/inst.isle line 1884.
            return v16;
        }
        F64 => {
            let v17 = constructor_x64_movsd_load(ctx, arg1);
            let v18 = C::xmm_to_reg(ctx, v17);
            // Rule at src/isa/x64/inst.isle line 1887.
            return v18;
        }
        F32X4 => {
            let v19 = constructor_x64_movups_load(ctx, arg1);
            let v20 = C::xmm_to_reg(ctx, v19);
            // Rule at src/isa/x64/inst.isle line 1890.
            return v20;
        }
        F64X2 => {
            let v21 = constructor_x64_movupd_load(ctx, arg1);
            let v22 = C::xmm_to_reg(ctx, v21);
            // Rule at src/isa/x64/inst.isle line 1893.
            return v22;
        }
        _ => {}
    }
    let v1 = C::fits_in_32(ctx, arg0);
    if let Some(v2) = v1 {
        if let &ExtKind::SignExtend = arg2 {
            let v5 = C::ty_bytes(ctx, v2);
            let v7 = &C::ext_mode(ctx, v5, 0x8);
            let v8 = &constructor_synthetic_amode_to_gpr_mem(ctx, arg1);
            let v9 = constructor_x64_movsx(ctx, v7, v8);
            let v10 = C::gpr_to_reg(ctx, v9);
            // Rule at src/isa/x64/inst.isle line 1875.
            return v10;
        }
    }
    let v23 = C::multi_lane(ctx, arg0);
    if let Some(v24) = v23 {
        let v27 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg1);
        let v28 = constructor_x64_movdqu_load(ctx, v27);
        let v29 = C::xmm_to_reg(ctx, v28);
        // Rule at src/isa/x64/inst.isle line 1896.
        return v29;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_load", "src/isa/x64/inst.isle line 1873"
    )
}
// Generated as internal constructor for term x64_mov.
pub fn constructor_x64_mov<C: Context>(ctx: &mut C, arg0: &Amode) -> Reg {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = &C::amode_to_synthetic_amode(ctx, arg0);
    let v3 = MInst::Mov64MR {
        src: v2.clone(),
        dst: v1,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = constructor_writable_gpr_to_r_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 1900.
    return v5;
}
// Generated as internal constructor for term x64_movzx.
pub fn constructor_x64_movzx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::MovzxRmR {
        ext_mode: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 1906.
    return v5;
}
// Generated as internal constructor for term x64_movsx.
pub fn constructor_x64_movsx<C: Context>(ctx: &mut C, arg0: &ExtMode, arg1: &GprMem) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::MovsxRmR {
        ext_mode: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 1912.
    return v5;
}
// Generated as internal constructor for term x64_movss_load.
pub fn constructor_x64_movss_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovss, v2);
        // Rule at src/isa/x64/inst.isle line 1920.
        return v6;
    }
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movss, v2);
    // Rule at src/isa/x64/inst.isle line 1918.
    return v3;
}
// Generated as internal constructor for term x64_movss_store.
pub fn constructor_x64_movss_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovss, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 1927.
        return v6.clone();
    }
    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1925.
    return v3.clone();
}
// Generated as internal constructor for term x64_movsd_load.
pub fn constructor_x64_movsd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovsd, v2);
        // Rule at src/isa/x64/inst.isle line 1934.
        return v6;
    }
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movsd, v2);
    // Rule at src/isa/x64/inst.isle line 1932.
    return v3;
}
// Generated as internal constructor for term x64_movsd_store.
pub fn constructor_x64_movsd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovsd, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 1941.
        return v6.clone();
    }
    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1939.
    return v3.clone();
}
// Generated as internal constructor for term x64_movups_load.
pub fn constructor_x64_movups_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovups, v2);
        // Rule at src/isa/x64/inst.isle line 1948.
        return v6;
    }
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movups, v2);
    // Rule at src/isa/x64/inst.isle line 1946.
    return v3;
}
// Generated as internal constructor for term x64_movups_store.
pub fn constructor_x64_movups_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovups, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 1955.
        return v6.clone();
    }
    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movups, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1953.
    return v3.clone();
}
// Generated as internal constructor for term x64_movupd_load.
pub fn constructor_x64_movupd_load<C: Context>(ctx: &mut C, arg0: &SyntheticAmode) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovupd, v2);
        // Rule at src/isa/x64/inst.isle line 1962.
        return v6;
    }
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movupd, v2);
    // Rule at src/isa/x64/inst.isle line 1960.
    return v3;
}
// Generated as internal constructor for term x64_movupd_store.
pub fn constructor_x64_movupd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovupd, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 1969.
        return v6.clone();
    }
    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movupd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 1967.
    return v3.clone();
}
// Generated as internal constructor for term x64_movd_to_gpr.
pub fn constructor_x64_movd_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);
        // Rule at src/isa/x64/inst.isle line 1977.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 1975.
    return v3;
}
// Generated as internal constructor for term x64_movd_to_xmm.
pub fn constructor_x64_movd_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovd, arg0, &OperandSize::Size32);
        // Rule at src/isa/x64/inst.isle line 1985.
        return v6;
    }
    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movd, arg0, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 1983.
    return v3;
}
// Generated as internal constructor for term x64_movq_to_xmm.
pub fn constructor_x64_movq_to_xmm<C: Context>(ctx: &mut C, arg0: &GprMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);
        // Rule at src/isa/x64/inst.isle line 1993.
        return v6;
    }
    let v3 = constructor_gpr_to_xmm(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);
    // Rule at src/isa/x64/inst.isle line 1991.
    return v3;
}
// Generated as internal constructor for term x64_movq_to_gpr.
pub fn constructor_x64_movq_to_gpr<C: Context>(ctx: &mut C, arg0: Xmm) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovq, arg0, &OperandSize::Size64);
        // Rule at src/isa/x64/inst.isle line 2001.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movq, arg0, &OperandSize::Size64);
    // Rule at src/isa/x64/inst.isle line 1999.
    return v3;
}
// Generated as internal constructor for term x64_movdqu_load.
pub fn constructor_x64_movdqu_load<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovdqu, arg0);
        // Rule at src/isa/x64/inst.isle line 2008.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movdqu, arg0);
    // Rule at src/isa/x64/inst.isle line 2006.
    return v2;
}
// Generated as internal constructor for term x64_movdqu_store.
pub fn constructor_x64_movdqu_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
) -> SideEffectNoResult {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &constructor_xmm_movrm_vex(ctx, &AvxOpcode::Vmovdqu, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 2015.
        return v6.clone();
    }
    let v3 = &constructor_xmm_movrm(ctx, &SseOpcode::Movdqu, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2013.
    return v3.clone();
}
// Generated as internal constructor for term x64_pmovsxbw.
pub fn constructor_x64_pmovsxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxbw, arg0);
        // Rule at src/isa/x64/inst.isle line 2022.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxbw, arg0);
    // Rule at src/isa/x64/inst.isle line 2020.
    return v2;
}
// Generated as internal constructor for term x64_pmovzxbw.
pub fn constructor_x64_pmovzxbw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxbw, arg0);
        // Rule at src/isa/x64/inst.isle line 2029.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxbw, arg0);
    // Rule at src/isa/x64/inst.isle line 2027.
    return v2;
}
// Generated as internal constructor for term x64_pmovsxwd.
pub fn constructor_x64_pmovsxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxwd, arg0);
        // Rule at src/isa/x64/inst.isle line 2036.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxwd, arg0);
    // Rule at src/isa/x64/inst.isle line 2034.
    return v2;
}
// Generated as internal constructor for term x64_pmovzxwd.
pub fn constructor_x64_pmovzxwd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxwd, arg0);
        // Rule at src/isa/x64/inst.isle line 2043.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxwd, arg0);
    // Rule at src/isa/x64/inst.isle line 2041.
    return v2;
}
// Generated as internal constructor for term x64_pmovsxdq.
pub fn constructor_x64_pmovsxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovsxdq, arg0);
        // Rule at src/isa/x64/inst.isle line 2050.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovsxdq, arg0);
    // Rule at src/isa/x64/inst.isle line 2048.
    return v2;
}
// Generated as internal constructor for term x64_pmovzxdq.
pub fn constructor_x64_pmovzxdq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpmovzxdq, arg0);
        // Rule at src/isa/x64/inst.isle line 2057.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Pmovzxdq, arg0);
    // Rule at src/isa/x64/inst.isle line 2055.
    return v2;
}
// Generated as internal constructor for term x64_movrm.
pub fn constructor_x64_movrm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &SyntheticAmode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v3 = &C::raw_operand_size_of_type(ctx, arg0);
    let v4 = MInst::MovRM {
        size: v3.clone(),
        src: arg2,
        dst: arg1.clone(),
    };
    let v5 = SideEffectNoResult::Inst { inst: v4 };
    // Rule at src/isa/x64/inst.isle line 2062.
    return v5;
}
// Generated as internal constructor for term xmm_movrm.
pub fn constructor_xmm_movrm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &SyntheticAmode,
    arg2: Xmm,
) -> SideEffectNoResult {
    let v3 = MInst::XmmMovRM {
        op: arg0.clone(),
        src: arg2,
        dst: arg1.clone(),
    };
    let v4 = SideEffectNoResult::Inst { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 2067.
    return v4;
}
// Generated as internal constructor for term xmm_movrm_imm.
pub fn constructor_xmm_movrm_imm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &SyntheticAmode,
    arg2: Xmm,
    arg3: u8,
) -> SideEffectNoResult {
    let v4 = MInst::XmmMovRMImm {
        op: arg0.clone(),
        src: arg2,
        dst: arg1.clone(),
        imm: arg3,
    };
    let v5 = SideEffectNoResult::Inst { inst: v4 };
    // Rule at src/isa/x64/inst.isle line 2071.
    return v5;
}
// Generated as internal constructor for term xmm_movrm_vex.
pub fn constructor_xmm_movrm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: &SyntheticAmode,
    arg2: Xmm,
) -> SideEffectNoResult {
    let v3 = MInst::XmmMovRMVex {
        op: arg0.clone(),
        src: arg2,
        dst: arg1.clone(),
    };
    let v4 = SideEffectNoResult::Inst { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 2075.
    return v4;
}
// Generated as internal constructor for term xmm_movrm_imm_vex.
pub fn constructor_xmm_movrm_imm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: &SyntheticAmode,
    arg2: Xmm,
    arg3: u8,
) -> SideEffectNoResult {
    let v4 = MInst::XmmMovRMImmVex {
        op: arg0.clone(),
        src: arg2,
        dst: arg1.clone(),
        imm: arg3,
    };
    let v5 = SideEffectNoResult::Inst { inst: v4 };
    // Rule at src/isa/x64/inst.isle line 2079.
    return v5;
}
// Generated as internal constructor for term x64_xmm_load_const.
pub fn constructor_x64_xmm_load_const<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: VCodeConstant,
) -> Xmm {
    let v2 = &C::const_to_synthetic_amode(ctx, arg1);
    let v4 = constructor_x64_load(ctx, arg0, v2, &ExtKind::None);
    let v5 = C::xmm_new(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 2084.
    return v5;
}
// Generated as internal constructor for term alu_rmi_r.
pub fn constructor_alu_rmi_r<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &AluRmiROpcode,
    arg2: Gpr,
    arg3: &GprMemImm,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v6 = MInst::AluRmiR {
        size: v5.clone(),
        op: arg1.clone(),
        src1: arg2,
        src2: arg3.clone(),
        dst: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 2095.
    return v8;
}
// Generated as internal constructor for term x64_add.
pub fn constructor_x64_add<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2103.
    return v4;
}
// Generated as internal constructor for term x64_add_with_flags_paired.
pub fn constructor_x64_add_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);
    let v6 = MInst::AluRmiR {
        size: v4.clone(),
        op: AluRmiROpcode::Add,
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 2111.
    return v8;
}
// Generated as internal constructor for term x64_adc_paired.
pub fn constructor_x64_adc_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesFlags {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);
    let v6 = MInst::AluRmiR {
        size: v4.clone(),
        op: AluRmiROpcode::Adc,
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 2123.
    return v8;
}
// Generated as internal constructor for term x64_sub.
pub fn constructor_x64_sub<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2135.
    return v4;
}
// Generated as internal constructor for term x64_sub_with_flags_paired.
pub fn constructor_x64_sub_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);
    let v6 = MInst::AluRmiR {
        size: v4.clone(),
        op: AluRmiROpcode::Sub,
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v8 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 2143.
    return v8;
}
// Generated as internal constructor for term x64_sbb_paired.
pub fn constructor_x64_sbb_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ConsumesFlags {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v3);
    let v6 = MInst::AluRmiR {
        size: v4.clone(),
        op: AluRmiROpcode::Sbb,
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v8 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 2155.
    return v8;
}
// Generated as internal constructor for term x64_mul.
pub fn constructor_x64_mul<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Mul, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2167.
    return v4;
}
// Generated as internal constructor for term x64_and.
pub fn constructor_x64_and<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2175.
    return v4;
}
// Generated as internal constructor for term x64_and_with_flags_paired.
pub fn constructor_x64_and_with_flags_paired<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> ProducesFlags {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v6 = MInst::AluRmiR {
        size: v4.clone(),
        op: AluRmiROpcode::And,
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v7 = ProducesFlags::ProducesFlagsSideEffect { inst: v6 };
    // Rule at src/isa/x64/inst.isle line 2182.
    return v7;
}
// Generated as internal constructor for term x64_or.
pub fn constructor_x64_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &GprMemImm) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2193.
    return v4;
}
// Generated as internal constructor for term x64_xor.
pub fn constructor_x64_xor<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMemImm,
) -> Gpr {
    let v4 = constructor_alu_rmi_r(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2201.
    return v4;
}
// Generated as internal constructor for term alu_rm_r_vex.
pub fn constructor_alu_rm_r_vex<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &AluRmROpcode,
    arg2: Gpr,
    arg3: Gpr,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v6 = MInst::AluRmRVex {
        size: v5.clone(),
        op: arg1.clone(),
        src1: arg2,
        src2: arg3,
        dst: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 2209.
    return v8;
}
// Generated as internal constructor for term x64_andn.
pub fn constructor_x64_andn<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {
    let v4 = constructor_alu_rm_r_vex(ctx, arg0, &AluRmROpcode::Andn, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2216.
    return v4;
}
// Generated as internal constructor for term imm_i64.
pub fn constructor_imm_i64<C: Context>(ctx: &mut C, arg0: Type, arg1: i64) -> Reg {
    let v2 = C::i64_as_u64(ctx, arg1);
    let v3 = constructor_imm(ctx, arg0, v2);
    // Rule at src/isa/x64/inst.isle line 2223.
    return v3;
}
// Generated as internal constructor for term imm.
pub fn constructor_imm<C: Context>(ctx: &mut C, arg0: Type, arg1: u64) -> Reg {
    match arg0 {
        I64 => {
            let v20 = C::nonzero_u64_fits_in_u32(ctx, arg1);
            if let Some(v21) = v20 {
                let v5 = C::temp_writable_gpr(ctx);
                let v23 = MInst::Imm {
                    dst_size: OperandSize::Size32,
                    simm64: v21,
                    dst: v5,
                };
                let v24 = C::emit(ctx, &v23);
                let v25 = constructor_writable_gpr_to_r_reg(ctx, v5);
                // Rule at src/isa/x64/inst.isle line 2254.
                return v25;
            }
        }
        F32 => {
            let v4 = C::u64_is_zero(ctx, arg1);
            match v4 {
                true => {
                    let v35 = constructor_xmm_zero(ctx, arg0);
                    let v36 = C::xmm_to_reg(ctx, v35);
                    // Rule at src/isa/x64/inst.isle line 2272.
                    return v36;
                }
                false => {
                    let v11 = constructor_imm(ctx, I32, arg1);
                    let v12 = &C::reg_to_gpr_mem(ctx, v11);
                    let v13 = constructor_x64_movd_to_xmm(ctx, v12);
                    let v14 = C::xmm_to_reg(ctx, v13);
                    // Rule at src/isa/x64/inst.isle line 2245.
                    return v14;
                }
                _ => {}
            }
        }
        F64 => {
            let v4 = C::u64_is_zero(ctx, arg1);
            match v4 {
                true => {
                    let v35 = constructor_xmm_zero(ctx, arg0);
                    let v36 = C::xmm_to_reg(ctx, v35);
                    // Rule at src/isa/x64/inst.isle line 2277.
                    return v36;
                }
                false => {
                    let v16 = constructor_imm(ctx, I64, arg1);
                    let v17 = &C::reg_to_gpr_mem(ctx, v16);
                    let v18 = constructor_x64_movq_to_xmm(ctx, v17);
                    let v19 = C::xmm_to_reg(ctx, v18);
                    // Rule at src/isa/x64/inst.isle line 2249.
                    return v19;
                }
                _ => {}
            }
        }
        _ => {}
    }
    let v1 = C::fits_in_64(ctx, arg0);
    if let Some(v2) = v1 {
        let v4 = C::u64_is_zero(ctx, arg1);
        match v4 {
            true => {
                let v5 = C::temp_writable_gpr(ctx);
                let v6 = &C::operand_size_of_type_32_64(ctx, v2);
                let v27 = MInst::AluConstOp {
                    op: AluRmiROpcode::Xor,
                    size: v6.clone(),
                    dst: v5,
                };
                let v28 = C::emit(ctx, &v27);
                let v29 = C::writable_gpr_to_gpr(ctx, v5);
                let v30 = C::gpr_to_reg(ctx, v29);
                // Rule at src/isa/x64/inst.isle line 2260.
                return v30;
            }
            false => {
                let v5 = C::temp_writable_gpr(ctx);
                let v6 = &C::operand_size_of_type_32_64(ctx, v2);
                let v7 = MInst::Imm {
                    dst_size: v6.clone(),
                    simm64: arg1,
                    dst: v5,
                };
                let v8 = C::emit(ctx, &v7);
                let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);
                // Rule at src/isa/x64/inst.isle line 2238.
                return v9;
            }
            _ => {}
        }
    }
    if arg1 == 0x0 {
        let v31 = C::multi_lane(ctx, arg0);
        if let Some(v32) = v31 {
            let v35 = constructor_xmm_zero(ctx, arg0);
            let v36 = C::xmm_to_reg(ctx, v35);
            // Rule at src/isa/x64/inst.isle line 2268.
            return v36;
        }
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "imm", "src/isa/x64/inst.isle line 2235"
    )
}
// Generated as internal constructor for term xmm_zero.
pub fn constructor_xmm_zero<C: Context>(ctx: &mut C, arg0: Type) -> Xmm {
    let v1 = constructor_xmm_uninit_value(ctx);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    let v3 = constructor_x64_xor_vector(ctx, arg0, v1, v2);
    // Rule at src/isa/x64/inst.isle line 2282.
    return v3;
}
// Generated as internal constructor for term shift_r.
pub fn constructor_shift_r<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &ShiftKind,
    arg2: Gpr,
    arg3: &Imm8Gpr,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = &C::raw_operand_size_of_type(ctx, arg0);
    let v6 = MInst::ShiftR {
        size: v5.clone(),
        kind: arg1.clone(),
        src: arg2,
        num_bits: arg3.clone(),
        dst: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 2288.
    return v8;
}
// Generated as internal constructor for term x64_rotl.
pub fn constructor_x64_rotl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {
    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateLeft, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2298.
    return v4;
}
// Generated as internal constructor for term x64_rotr.
pub fn constructor_x64_rotr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {
    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::RotateRight, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2303.
    return v4;
}
// Generated as internal constructor for term x64_shl.
pub fn constructor_x64_shl<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {
    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftLeft, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2308.
    return v4;
}
// Generated as internal constructor for term x64_shr.
pub fn constructor_x64_shr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {
    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightLogical, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2313.
    return v4;
}
// Generated as internal constructor for term x64_sar.
pub fn constructor_x64_sar<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: &Imm8Gpr) -> Gpr {
    let v4 = constructor_shift_r(ctx, arg0, &ShiftKind::ShiftRightArithmetic, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2318.
    return v4;
}
// Generated as internal constructor for term x64_bswap.
pub fn constructor_x64_bswap<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v4 = MInst::Bswap {
        size: v3.clone(),
        src: arg1,
        dst: v2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 2325.
    return v6;
}
// Generated as internal constructor for term cmp_rmi_r.
pub fn constructor_cmp_rmi_r<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &CmpOpcode,
    arg2: &GprMemImm,
    arg3: Gpr,
) -> ProducesFlags {
    let v4 = MInst::CmpRmiR {
        size: arg0.clone(),
        opcode: arg1.clone(),
        src: arg2.clone(),
        dst: arg3,
    };
    let v5 = ProducesFlags::ProducesFlagsSideEffect { inst: v4 };
    // Rule at src/isa/x64/inst.isle line 2333.
    return v5;
}
// Generated as internal constructor for term x64_cmp.
pub fn constructor_x64_cmp<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &GprMemImm,
    arg2: Gpr,
) -> ProducesFlags {
    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2342.
    return v4.clone();
}
// Generated as internal constructor for term x64_cmp_imm.
pub fn constructor_x64_cmp_imm<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: u32,
    arg2: Gpr,
) -> ProducesFlags {
    let v4 = RegMemImm::Imm { simm32: arg1 };
    let v5 = &C::gpr_mem_imm_new(ctx, &v4);
    let v6 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Cmp, v5, arg2);
    // Rule at src/isa/x64/inst.isle line 2347.
    return v6.clone();
}
// Generated as internal constructor for term xmm_cmp_rm_r.
pub fn constructor_xmm_cmp_rm_r<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &XmmMemAligned,
    arg2: Xmm,
) -> ProducesFlags {
    let v3 = MInst::XmmCmpRmR {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: arg2,
    };
    let v4 = ProducesFlags::ProducesFlagsSideEffect { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 2352.
    return v4;
}
// Generated as internal constructor for term x64_ucomis.
pub fn constructor_x64_ucomis<C: Context>(ctx: &mut C, arg0: Value, arg1: Value) -> ProducesFlags {
    let v1 = C::value_type(ctx, arg0);
    match v1 {
        F32 => {
            let v4 = constructor_put_in_xmm(ctx, arg0);
            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);
            let v6 = constructor_put_in_xmm(ctx, arg1);
            let v7 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomiss, v5, v6);
            // Rule at src/isa/x64/inst.isle line 2358.
            return v7.clone();
        }
        F64 => {
            let v4 = constructor_put_in_xmm(ctx, arg0);
            let v5 = &constructor_xmm_to_xmm_mem_aligned(ctx, v4);
            let v6 = constructor_put_in_xmm(ctx, arg1);
            let v9 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ucomisd, v5, v6);
            // Rule at src/isa/x64/inst.isle line 2362.
            return v9.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_ucomis", "src/isa/x64/inst.isle line 2357"
    )
}
// Generated as internal constructor for term x64_test.
pub fn constructor_x64_test<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: &GprMemImm,
    arg2: Gpr,
) -> ProducesFlags {
    let v4 = &constructor_cmp_rmi_r(ctx, arg0, &CmpOpcode::Test, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 2367.
    return v4.clone();
}
// Generated as internal constructor for term x64_ptest.
pub fn constructor_x64_ptest<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> ProducesFlags {
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = &constructor_xmm_cmp_rm_r(ctx, &SseOpcode::Ptest, v3, arg1);
    // Rule at src/isa/x64/inst.isle line 2372.
    return v4.clone();
}
// Generated as internal constructor for term cmove.
pub fn constructor_cmove<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &GprMem,
    arg3: Gpr,
) -> ConsumesFlags {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v4);
    let v6 = MInst::Cmove {
        size: v5.clone(),
        cc: arg1.clone(),
        consequent: arg2.clone(),
        alternative: arg3,
        dst: v4,
    };
    let v8 = ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 2379.
    return v8;
}
// Generated as internal constructor for term cmove_xmm.
pub fn constructor_cmove_xmm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &XmmMemAligned,
    arg3: Xmm,
) -> ConsumesFlags {
    let v4 = C::temp_writable_xmm(ctx);
    let v6 = constructor_writable_xmm_to_r_reg(ctx, v4);
    let v5 = MInst::XmmCmove {
        ty: arg0,
        cc: arg1.clone(),
        consequent: arg2.clone(),
        alternative: arg3,
        dst: v4,
    };
    let v7 = ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: v5,
        result: v6,
    };
    // Rule at src/isa/x64/inst.isle line 2387.
    return v7;
}
// Generated as internal constructor for term cmove_from_values.
pub fn constructor_cmove_from_values<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: Value,
    arg3: Value,
) -> ConsumesFlags {
    let v1 = &C::type_register_class(ctx, arg0);
    if let Some(v2) = v1 {
        match v2 {
            &RegisterClass::Gpr {
                single_register: v3,
            } => {
                match v3 {
                    true => {
                        let v26 = &constructor_put_in_gpr_mem(ctx, arg2);
                        let v27 = constructor_put_in_gpr(ctx, arg3);
                        let v28 = &constructor_cmove(ctx, arg0, arg1, v26, v27);
                        // Rule at src/isa/x64/inst.isle line 2418.
                        return v28.clone();
                    }
                    false => {
                        if arg0 == I128 {
                            let v7 = C::put_in_regs(ctx, arg2);
                            let v8 = C::put_in_regs(ctx, arg3);
                            let v9 = C::temp_writable_gpr(ctx);
                            let v10 = C::temp_writable_gpr(ctx);
                            let v13 = constructor_value_regs_get_gpr(ctx, v7, 0x0);
                            let v14 = &C::gpr_to_gpr_mem(ctx, v13);
                            let v15 = constructor_value_regs_get_gpr(ctx, v8, 0x0);
                            let v18 = constructor_value_regs_get_gpr(ctx, v7, 0x1);
                            let v19 = &C::gpr_to_gpr_mem(ctx, v18);
                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x1);
                            let v22 = constructor_writable_gpr_to_r_reg(ctx, v9);
                            let v23 = constructor_writable_gpr_to_r_reg(ctx, v10);
                            let v24 = C::value_regs(ctx, v22, v23);
                            let v16 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg1.clone(),
                                consequent: v14.clone(),
                                alternative: v15,
                                dst: v9,
                            };
                            let v21 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg1.clone(),
                                consequent: v19.clone(),
                                alternative: v20,
                                dst: v10,
                            };
                            let v25 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
                                inst1: v16,
                                inst2: v21,
                                result: v24,
                            };
                            // Rule at src/isa/x64/inst.isle line 2397.
                            return v25;
                        }
                    }
                    _ => {}
                }
            }
            &RegisterClass::Xmm => {
                let v29 = &constructor_put_in_xmm_mem_aligned(ctx, arg2);
                let v30 = constructor_put_in_xmm(ctx, arg3);
                let v31 = &constructor_cmove_xmm(ctx, arg0, arg1, v29, v30);
                // Rule at src/isa/x64/inst.isle line 2421.
                return v31.clone();
            }
            _ => {}
        }
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "cmove_from_values", "src/isa/x64/inst.isle line 2396"
    )
}
// Generated as internal constructor for term cmove_or.
pub fn constructor_cmove_or<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &CC,
    arg3: &GprMem,
    arg4: Gpr,
) -> ConsumesFlags {
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v9 = C::writable_gpr_to_gpr(ctx, v6);
    let v11 = constructor_writable_gpr_to_value_regs(ctx, v5);
    let v8 = MInst::Cmove {
        size: v7.clone(),
        cc: arg1.clone(),
        consequent: arg3.clone(),
        alternative: arg4,
        dst: v6,
    };
    let v10 = MInst::Cmove {
        size: v7.clone(),
        cc: arg2.clone(),
        consequent: arg3.clone(),
        alternative: v9,
        dst: v5,
    };
    let v12 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
        inst1: v8,
        inst2: v10,
        result: v11,
    };
    // Rule at src/isa/x64/inst.isle line 2428.
    return v12;
}
// Generated as internal constructor for term cmove_or_xmm.
pub fn constructor_cmove_or_xmm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &CC,
    arg3: &XmmMemAligned,
    arg4: Xmm,
) -> ConsumesFlags {
    let v5 = C::temp_writable_xmm(ctx);
    let v6 = C::temp_writable_xmm(ctx);
    let v8 = C::writable_xmm_to_xmm(ctx, v6);
    let v10 = constructor_writable_xmm_to_value_regs(ctx, v5);
    let v7 = MInst::XmmCmove {
        ty: arg0,
        cc: arg1.clone(),
        consequent: arg3.clone(),
        alternative: arg4,
        dst: v6,
    };
    let v9 = MInst::XmmCmove {
        ty: arg0,
        cc: arg2.clone(),
        consequent: arg3.clone(),
        alternative: v8,
        dst: v5,
    };
    let v11 = ConsumesFlags::ConsumesFlagsTwiceReturnsValueRegs {
        inst1: v7,
        inst2: v9,
        result: v10,
    };
    // Rule at src/isa/x64/inst.isle line 2440.
    return v11;
}
// Generated as internal constructor for term cmove_or_from_values.
pub fn constructor_cmove_or_from_values<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: &CC,
    arg3: Value,
    arg4: Value,
) -> ConsumesFlags {
    let v1 = &C::type_register_class(ctx, arg0);
    if let Some(v2) = v1 {
        match v2 {
            &RegisterClass::Gpr {
                single_register: v3,
            } => {
                match v3 {
                    true => {
                        let v37 = &constructor_put_in_gpr_mem(ctx, arg3);
                        let v38 = constructor_put_in_gpr(ctx, arg4);
                        let v39 = &constructor_cmove_or(ctx, arg0, arg1, arg2, v37, v38);
                        // Rule at src/isa/x64/inst.isle line 2473.
                        return v39.clone();
                    }
                    false => {
                        if arg0 == I128 {
                            let v8 = C::put_in_regs(ctx, arg3);
                            let v9 = C::put_in_regs(ctx, arg4);
                            let v10 = C::temp_writable_gpr(ctx);
                            let v11 = C::temp_writable_gpr(ctx);
                            let v12 = C::temp_writable_gpr(ctx);
                            let v13 = C::temp_writable_gpr(ctx);
                            let v16 = constructor_value_regs_get_gpr(ctx, v8, 0x0);
                            let v17 = &C::gpr_to_gpr_mem(ctx, v16);
                            let v18 = constructor_value_regs_get_gpr(ctx, v9, 0x0);
                            let v20 = constructor_value_regs_get_gpr(ctx, v8, 0x0);
                            let v21 = &C::gpr_to_gpr_mem(ctx, v20);
                            let v22 = C::writable_gpr_to_gpr(ctx, v12);
                            let v25 = constructor_value_regs_get_gpr(ctx, v8, 0x1);
                            let v26 = &C::gpr_to_gpr_mem(ctx, v25);
                            let v27 = constructor_value_regs_get_gpr(ctx, v9, 0x1);
                            let v29 = constructor_value_regs_get_gpr(ctx, v8, 0x1);
                            let v30 = &C::gpr_to_gpr_mem(ctx, v29);
                            let v31 = C::writable_gpr_to_gpr(ctx, v13);
                            let v33 = constructor_writable_gpr_to_r_reg(ctx, v10);
                            let v34 = constructor_writable_gpr_to_r_reg(ctx, v11);
                            let v35 = C::value_regs(ctx, v33, v34);
                            let v19 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg1.clone(),
                                consequent: v17.clone(),
                                alternative: v18,
                                dst: v12,
                            };
                            let v23 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg2.clone(),
                                consequent: v21.clone(),
                                alternative: v22,
                                dst: v10,
                            };
                            let v28 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg1.clone(),
                                consequent: v26.clone(),
                                alternative: v27,
                                dst: v13,
                            };
                            let v32 = MInst::Cmove {
                                size: OperandSize::Size64,
                                cc: arg2.clone(),
                                consequent: v30.clone(),
                                alternative: v31,
                                dst: v11,
                            };
                            let v36 = ConsumesFlags::ConsumesFlagsFourTimesReturnsValueRegs {
                                inst1: v19,
                                inst2: v23,
                                inst3: v28,
                                inst4: v32,
                                result: v35,
                            };
                            // Rule at src/isa/x64/inst.isle line 2454.
                            return v36;
                        }
                    }
                    _ => {}
                }
            }
            &RegisterClass::Xmm => {
                let v40 = &constructor_put_in_xmm_mem_aligned(ctx, arg3);
                let v41 = constructor_put_in_xmm(ctx, arg4);
                let v42 = &constructor_cmove_or_xmm(ctx, arg0, arg1, arg2, v40, v41);
                // Rule at src/isa/x64/inst.isle line 2476.
                return v42.clone();
            }
            _ => {}
        }
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "cmove_or_from_values", "src/isa/x64/inst.isle line 2453"
    )
}
// Generated as internal constructor for term x64_setcc.
pub fn constructor_x64_setcc<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {
    let v1 = C::temp_writable_gpr(ctx);
    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);
    let v2 = MInst::Setcc {
        cc: arg0.clone(),
        dst: v1,
    };
    let v4 = ConsumesFlags::ConsumesFlagsReturnsReg {
        inst: v2,
        result: v3,
    };
    // Rule at src/isa/x64/inst.isle line 2481.
    return v4;
}
// Generated as internal constructor for term x64_setcc_paired.
pub fn constructor_x64_setcc_paired<C: Context>(ctx: &mut C, arg0: &CC) -> ConsumesFlags {
    let v1 = C::temp_writable_gpr(ctx);
    let v3 = constructor_writable_gpr_to_r_reg(ctx, v1);
    let v2 = MInst::Setcc {
        cc: arg0.clone(),
        dst: v1,
    };
    let v4 = ConsumesFlags::ConsumesFlagsReturnsResultWithProducer {
        inst: v2,
        result: v3,
    };
    // Rule at src/isa/x64/inst.isle line 2490.
    return v4;
}
// Generated as internal constructor for term xmm_rm_r.
pub fn constructor_xmm_rm_r<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: &XmmMemAligned,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmRmR {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 2498.
    return v6;
}
// Generated as internal constructor for term xmm_rm_r_unaligned.
pub fn constructor_xmm_rm_r_unaligned<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmRmRUnaligned {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 2505.
    return v6;
}
// Generated as internal constructor for term x64_paddb.
pub fn constructor_x64_paddb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2514.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2512.
    return v4;
}
// Generated as internal constructor for term x64_paddw.
pub fn constructor_x64_paddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2522.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2520.
    return v4;
}
// Generated as internal constructor for term x64_paddd.
pub fn constructor_x64_paddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2530.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2528.
    return v4;
}
// Generated as internal constructor for term x64_paddq.
pub fn constructor_x64_paddq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2538.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2536.
    return v4;
}
// Generated as internal constructor for term x64_paddsb.
pub fn constructor_x64_paddsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2546.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2544.
    return v4;
}
// Generated as internal constructor for term x64_paddsw.
pub fn constructor_x64_paddsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2554.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2552.
    return v4;
}
// Generated as internal constructor for term x64_phaddw.
pub fn constructor_x64_phaddw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2562.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2560.
    return v4;
}
// Generated as internal constructor for term x64_phaddd.
pub fn constructor_x64_phaddd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vphaddd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2570.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Phaddd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2568.
    return v4;
}
// Generated as internal constructor for term x64_paddusb.
pub fn constructor_x64_paddusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2578.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2576.
    return v4;
}
// Generated as internal constructor for term x64_paddusw.
pub fn constructor_x64_paddusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpaddusw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2586.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Paddusw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2584.
    return v4;
}
// Generated as internal constructor for term x64_psubb.
pub fn constructor_x64_psubb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2594.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2592.
    return v4;
}
// Generated as internal constructor for term x64_psubw.
pub fn constructor_x64_psubw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2602.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2600.
    return v4;
}
// Generated as internal constructor for term x64_psubd.
pub fn constructor_x64_psubd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2610.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2608.
    return v4;
}
// Generated as internal constructor for term x64_psubq.
pub fn constructor_x64_psubq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2618.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2616.
    return v4;
}
// Generated as internal constructor for term x64_psubsb.
pub fn constructor_x64_psubsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2626.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2624.
    return v4;
}
// Generated as internal constructor for term x64_psubsw.
pub fn constructor_x64_psubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2634.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2632.
    return v4;
}
// Generated as internal constructor for term x64_psubusb.
pub fn constructor_x64_psubusb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2642.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2640.
    return v4;
}
// Generated as internal constructor for term x64_psubusw.
pub fn constructor_x64_psubusw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsubusw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2650.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Psubusw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2648.
    return v4;
}
// Generated as internal constructor for term x64_pavgb.
pub fn constructor_x64_pavgb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2658.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2656.
    return v4;
}
// Generated as internal constructor for term x64_pavgw.
pub fn constructor_x64_pavgw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpavgw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2666.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pavgw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2664.
    return v4;
}
// Generated as internal constructor for term x64_pand.
pub fn constructor_x64_pand<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpand, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2674.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pand, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2672.
    return v4;
}
// Generated as internal constructor for term x64_andps.
pub fn constructor_x64_andps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2682.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2680.
    return v4;
}
// Generated as internal constructor for term x64_andpd.
pub fn constructor_x64_andpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2690.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2688.
    return v4;
}
// Generated as internal constructor for term x64_por.
pub fn constructor_x64_por<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpor, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2698.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Por, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2696.
    return v4;
}
// Generated as internal constructor for term x64_orps.
pub fn constructor_x64_orps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2706.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2704.
    return v4;
}
// Generated as internal constructor for term x64_orpd.
pub fn constructor_x64_orpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vorpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2714.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Orpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2712.
    return v4;
}
// Generated as internal constructor for term x64_pxor.
pub fn constructor_x64_pxor<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpxor, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2722.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pxor, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2720.
    return v4;
}
// Generated as internal constructor for term x64_xorps.
pub fn constructor_x64_xorps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2730.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2728.
    return v4;
}
// Generated as internal constructor for term x64_xorpd.
pub fn constructor_x64_xorpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vxorpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2738.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Xorpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2736.
    return v4;
}
// Generated as internal constructor for term x64_pmullw.
pub fn constructor_x64_pmullw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmullw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2746.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmullw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2744.
    return v4;
}
// Generated as internal constructor for term x64_pmulld.
pub fn constructor_x64_pmulld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulld, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2754.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulld, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2752.
    return v4;
}
// Generated as internal constructor for term x64_pmulhw.
pub fn constructor_x64_pmulhw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2762.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2760.
    return v4;
}
// Generated as internal constructor for term x64_pmulhrsw.
pub fn constructor_x64_pmulhrsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhrsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2770.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhrsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2768.
    return v4;
}
// Generated as internal constructor for term x64_pmulhuw.
pub fn constructor_x64_pmulhuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmulhuw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2778.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmulhuw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2776.
    return v4;
}
// Generated as internal constructor for term x64_pmuldq.
pub fn constructor_x64_pmuldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuldq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2786.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuldq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2784.
    return v4;
}
// Generated as internal constructor for term x64_pmuludq.
pub fn constructor_x64_pmuludq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmuludq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2794.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmuludq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2792.
    return v4;
}
// Generated as internal constructor for term x64_punpckhwd.
pub fn constructor_x64_punpckhwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhwd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2802.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhwd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2800.
    return v4;
}
// Generated as internal constructor for term x64_punpcklwd.
pub fn constructor_x64_punpcklwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklwd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2810.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklwd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2808.
    return v4;
}
// Generated as internal constructor for term x64_punpckldq.
pub fn constructor_x64_punpckldq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckldq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2818.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckldq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2816.
    return v4;
}
// Generated as internal constructor for term x64_punpckhdq.
pub fn constructor_x64_punpckhdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhdq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2826.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhdq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2824.
    return v4;
}
// Generated as internal constructor for term x64_punpcklqdq.
pub fn constructor_x64_punpcklqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklqdq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2834.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklqdq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2832.
    return v4;
}
// Generated as internal constructor for term x64_punpckhqdq.
pub fn constructor_x64_punpckhqdq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhqdq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2842.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhqdq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2840.
    return v4;
}
// Generated as internal constructor for term x64_unpcklps.
pub fn constructor_x64_unpcklps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vunpcklps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2850.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Unpcklps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2848.
    return v4;
}
// Generated as internal constructor for term x64_andnps.
pub fn constructor_x64_andnps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2858.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2856.
    return v4;
}
// Generated as internal constructor for term x64_andnpd.
pub fn constructor_x64_andnpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vandnpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2866.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Andnpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2864.
    return v4;
}
// Generated as internal constructor for term x64_pandn.
pub fn constructor_x64_pandn<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpandn, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2874.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pandn, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2872.
    return v4;
}
// Generated as internal constructor for term x64_addss.
pub fn constructor_x64_addss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2882.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2880.
    return v3;
}
// Generated as internal constructor for term x64_addsd.
pub fn constructor_x64_addsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2890.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Addsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2888.
    return v3;
}
// Generated as internal constructor for term x64_addps.
pub fn constructor_x64_addps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2898.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2896.
    return v4;
}
// Generated as internal constructor for term x64_addpd.
pub fn constructor_x64_addpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vaddpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2906.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Addpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2904.
    return v4;
}
// Generated as internal constructor for term x64_subss.
pub fn constructor_x64_subss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2914.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2912.
    return v3;
}
// Generated as internal constructor for term x64_subsd.
pub fn constructor_x64_subsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2922.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Subsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2920.
    return v3;
}
// Generated as internal constructor for term x64_subps.
pub fn constructor_x64_subps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2930.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2928.
    return v4;
}
// Generated as internal constructor for term x64_subpd.
pub fn constructor_x64_subpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vsubpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2938.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Subpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2936.
    return v4;
}
// Generated as internal constructor for term x64_mulss.
pub fn constructor_x64_mulss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2946.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2944.
    return v3;
}
// Generated as internal constructor for term x64_mulsd.
pub fn constructor_x64_mulsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2954.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Mulsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2952.
    return v3;
}
// Generated as internal constructor for term x64_mulps.
pub fn constructor_x64_mulps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2962.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2960.
    return v4;
}
// Generated as internal constructor for term x64_mulpd.
pub fn constructor_x64_mulpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmulpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2970.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Mulpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2968.
    return v4;
}
// Generated as internal constructor for term x64_divss.
pub fn constructor_x64_divss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2978.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2976.
    return v3;
}
// Generated as internal constructor for term x64_divsd.
pub fn constructor_x64_divsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 2986.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Divsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 2984.
    return v3;
}
// Generated as internal constructor for term x64_divps.
pub fn constructor_x64_divps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 2994.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 2992.
    return v4;
}
// Generated as internal constructor for term x64_divpd.
pub fn constructor_x64_divpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vdivpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3002.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Divpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3000.
    return v4;
}
// Generated as internal constructor for term xmm_rm_r_blend.
pub fn constructor_xmm_rm_r_blend<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: &XmmMemAligned,
    arg3: Xmm,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = MInst::XmmRmRBlend {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        mask: arg3,
        dst: v4,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3008.
    return v7;
}
// Generated as internal constructor for term xmm_rmr_blend_vex.
pub fn constructor_xmm_rmr_blend_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: &XmmMem,
    arg3: Xmm,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = MInst::XmmRmRBlendVex {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        mask: arg3,
        dst: v4,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3015.
    return v7;
}
// Generated as internal constructor for term xmm_unary_rm_r_vex.
pub fn constructor_xmm_unary_rm_r_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::temp_writable_xmm(ctx);
    let v3 = MInst::XmmUnaryRmRVex {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xmm_to_xmm(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3022.
    return v5;
}
// Generated as internal constructor for term xmm_unary_rm_r_imm_vex.
pub fn constructor_xmm_unary_rm_r_imm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmUnaryRmRImmVex {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v3,
        imm: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3029.
    return v6;
}
// Generated as internal constructor for term x64_blend.
pub fn constructor_x64_blend<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
    arg3: Xmm,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v4 = constructor_x64_blendvps(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3036.
            return v4;
        }
        F64X2 => {
            let v5 = constructor_x64_blendvpd(ctx, arg3, arg2, arg1);
            // Rule at src/isa/x64/inst.isle line 3037.
            return v5;
        }
        _ => {}
    }
    let v6 = C::multi_lane(ctx, arg0);
    if let Some(v7) = v6 {
        let v10 = constructor_x64_pblendvb(ctx, arg3, arg2, arg1);
        // Rule at src/isa/x64/inst.isle line 3038.
        return v10;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_blend", "src/isa/x64/inst.isle line 3035"
    )
}
// Generated as internal constructor for term x64_blendvpd.
pub fn constructor_x64_blendvpd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvpd, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3044.
        return v8;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvpd, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 3042.
    return v5;
}
// Generated as internal constructor for term x64_blendvps.
pub fn constructor_x64_blendvps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vblendvps, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3052.
        return v8;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Blendvps, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 3050.
    return v5;
}
// Generated as internal constructor for term x64_pblendvb.
pub fn constructor_x64_pblendvb<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = constructor_xmm_rmr_blend_vex(ctx, &AvxOpcode::Vpblendvb, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3060.
        return v8;
    }
    let v4 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v5 = constructor_xmm_rm_r_blend(ctx, &SseOpcode::Pblendvb, arg0, v4, arg2);
    // Rule at src/isa/x64/inst.isle line 3058.
    return v5;
}
// Generated as internal constructor for term x64_pblendw.
pub fn constructor_x64_pblendw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpblendw, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3068.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pblendw, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3066.
    return v7;
}
// Generated as internal constructor for term x64_movsd_regmove.
pub fn constructor_x64_movsd_regmove<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovsd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3083.
        return v8;
    }
    let v3 = &C::xmm_to_xmm_mem(ctx, arg1);
    let v4 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Movsd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3081.
    return v4;
}
// Generated as internal constructor for term x64_movlhps.
pub fn constructor_x64_movlhps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmovlhps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3091.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Movlhps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3089.
    return v4;
}
// Generated as internal constructor for term x64_pmaxs.
pub fn constructor_x64_pmaxs<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pmaxsb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3097.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pmaxsw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3098.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pmaxsd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3099.
            return v5;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pmaxs", "src/isa/x64/inst.isle line 3096"
    )
}
// Generated as internal constructor for term x64_pmaxsb.
pub fn constructor_x64_pmaxsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3103.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3102.
    return v4;
}
// Generated as internal constructor for term x64_pmaxsw.
pub fn constructor_x64_pmaxsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3108.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3107.
    return v4;
}
// Generated as internal constructor for term x64_pmaxsd.
pub fn constructor_x64_pmaxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxsd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3113.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxsd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3112.
    return v4;
}
// Generated as internal constructor for term x64_pmins.
pub fn constructor_x64_pmins<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pminsb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3119.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pminsw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3120.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pminsd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3121.
            return v5;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pmins", "src/isa/x64/inst.isle line 3118"
    )
}
// Generated as internal constructor for term x64_pminsb.
pub fn constructor_x64_pminsb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3125.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3124.
    return v4;
}
// Generated as internal constructor for term x64_pminsw.
pub fn constructor_x64_pminsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3130.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3129.
    return v4;
}
// Generated as internal constructor for term x64_pminsd.
pub fn constructor_x64_pminsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminsd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3135.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminsd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3134.
    return v4;
}
// Generated as internal constructor for term x64_pmaxu.
pub fn constructor_x64_pmaxu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pmaxub(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3141.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pmaxuw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3142.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pmaxud(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3143.
            return v5;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pmaxu", "src/isa/x64/inst.isle line 3140"
    )
}
// Generated as internal constructor for term x64_pmaxub.
pub fn constructor_x64_pmaxub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxub, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3147.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxub, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3146.
    return v4;
}
// Generated as internal constructor for term x64_pmaxuw.
pub fn constructor_x64_pmaxuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxuw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3152.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxuw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3151.
    return v4;
}
// Generated as internal constructor for term x64_pmaxud.
pub fn constructor_x64_pmaxud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaxud, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3157.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaxud, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3156.
    return v4;
}
// Generated as internal constructor for term x64_pminu.
pub fn constructor_x64_pminu<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pminub(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3163.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pminuw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3164.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pminud(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 3165.
            return v5;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pminu", "src/isa/x64/inst.isle line 3162"
    )
}
// Generated as internal constructor for term x64_pminub.
pub fn constructor_x64_pminub<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminub, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3169.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminub, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3168.
    return v4;
}
// Generated as internal constructor for term x64_pminuw.
pub fn constructor_x64_pminuw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminuw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3174.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminuw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3173.
    return v4;
}
// Generated as internal constructor for term x64_pminud.
pub fn constructor_x64_pminud<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpminud, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3179.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pminud, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3178.
    return v4;
}
// Generated as internal constructor for term x64_punpcklbw.
pub fn constructor_x64_punpcklbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpcklbw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3187.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpcklbw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3185.
    return v4;
}
// Generated as internal constructor for term x64_punpckhbw.
pub fn constructor_x64_punpckhbw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpunpckhbw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3195.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Punpckhbw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3193.
    return v4;
}
// Generated as internal constructor for term x64_packsswb.
pub fn constructor_x64_packsswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpacksswb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3203.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packsswb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3201.
    return v4;
}
// Generated as internal constructor for term x64_packssdw.
pub fn constructor_x64_packssdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackssdw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3211.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packssdw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3209.
    return v4;
}
// Generated as internal constructor for term x64_packuswb.
pub fn constructor_x64_packuswb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackuswb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3219.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packuswb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3217.
    return v4;
}
// Generated as internal constructor for term x64_packusdw.
pub fn constructor_x64_packusdw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpackusdw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3227.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Packusdw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3225.
    return v4;
}
// Generated as internal constructor for term xmm_rm_r_imm.
pub fn constructor_xmm_rm_r_imm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Reg,
    arg2: &RegMem,
    arg3: u8,
    arg4: &OperandSize,
) -> Xmm {
    let v5 = C::temp_writable_xmm(ctx);
    let v6 = C::writable_xmm_to_reg(ctx, v5);
    let v7 = MInst::XmmRmRImm {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v6,
        imm: arg3,
        size: arg4.clone(),
    };
    let v8 = C::emit(ctx, &v7);
    let v9 = C::writable_xmm_to_xmm(ctx, v5);
    // Rule at src/isa/x64/inst.isle line 3233.
    return v9;
}
// Generated as internal constructor for term x64_palignr.
pub fn constructor_x64_palignr<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vpalignr, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3251.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Palignr, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3245.
    return v7;
}
// Generated as internal constructor for term x64_cmpp.
pub fn constructor_x64_cmpp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
    arg3: &FcmpImm,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v4 = constructor_x64_cmpps(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3257.
            return v4;
        }
        F64X2 => {
            let v5 = constructor_x64_cmppd(ctx, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3258.
            return v5;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_cmpp", "src/isa/x64/inst.isle line 3256"
    )
}
// Generated as internal constructor for term x64_cmpps.
pub fn constructor_x64_cmpps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: &FcmpImm,
) -> Xmm {
    let v9 = C::use_avx_simd(ctx);
    if v9 == true {
        let v11 = C::encode_fcmp_imm(ctx, arg2);
        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmpps, arg0, arg1, v11);
        // Rule at src/isa/x64/inst.isle line 3267.
        return v12;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v6 = C::encode_fcmp_imm(ctx, arg2);
    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmpps, v4, v5, v6, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3261.
    return v8;
}
// Generated as internal constructor for term x64_cmppd.
pub fn constructor_x64_cmppd<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: &FcmpImm,
) -> Xmm {
    let v9 = C::use_avx_simd(ctx);
    if v9 == true {
        let v11 = C::encode_fcmp_imm(ctx, arg2);
        let v12 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vcmppd, arg0, arg1, v11);
        // Rule at src/isa/x64/inst.isle line 3284.
        return v12;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v6 = C::encode_fcmp_imm(ctx, arg2);
    let v8 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Cmppd, v4, v5, v6, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3278.
    return v8;
}
// Generated as internal constructor for term x64_pinsrb.
pub fn constructor_x64_pinsrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrb, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3299.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrb, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3293.
    return v7;
}
// Generated as internal constructor for term x64_pinsrw.
pub fn constructor_x64_pinsrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrw, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3311.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrw, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3305.
    return v7;
}
// Generated as internal constructor for term x64_pinsrd.
pub fn constructor_x64_pinsrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrd, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3323.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3317.
    return v7;
}
// Generated as internal constructor for term x64_pinsrq.
pub fn constructor_x64_pinsrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &GprMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_vex_pinsr(ctx, &AvxOpcode::Vpinsrq, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3335.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::gpr_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Pinsrd, v4, v5, arg2, &OperandSize::Size64);
    // Rule at src/isa/x64/inst.isle line 3329.
    return v7;
}
// Generated as internal constructor for term xmm_vex_pinsr.
pub fn constructor_xmm_vex_pinsr<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: &GprMem,
    arg3: u8,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = MInst::XmmVexPinsr {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v4,
        imm: arg3,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3341.
    return v7;
}
// Generated as internal constructor for term xmm_unary_rm_r_imm.
pub fn constructor_xmm_unary_rm_r_imm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &XmmMemAligned,
    arg2: u8,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmUnaryRmRImm {
        op: arg0.clone(),
        src: arg1.clone(),
        imm: arg2,
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3348.
    return v6;
}
// Generated as internal constructor for term x64_roundss.
pub fn constructor_x64_roundss<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = C::encode_round_imm(ctx, arg1);
        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundss, arg0, v8);
        // Rule at src/isa/x64/inst.isle line 3357.
        return v9;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = C::encode_round_imm(ctx, arg1);
    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundss, v3, v4);
    // Rule at src/isa/x64/inst.isle line 3355.
    return v5;
}
// Generated as internal constructor for term x64_roundsd.
pub fn constructor_x64_roundsd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = C::encode_round_imm(ctx, arg1);
        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundsd, arg0, v8);
        // Rule at src/isa/x64/inst.isle line 3365.
        return v9;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = C::encode_round_imm(ctx, arg1);
    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundsd, v3, v4);
    // Rule at src/isa/x64/inst.isle line 3363.
    return v5;
}
// Generated as internal constructor for term x64_roundps.
pub fn constructor_x64_roundps<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = C::encode_round_imm(ctx, arg1);
        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundps, arg0, v8);
        // Rule at src/isa/x64/inst.isle line 3373.
        return v9;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = C::encode_round_imm(ctx, arg1);
    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundps, v3, v4);
    // Rule at src/isa/x64/inst.isle line 3371.
    return v5;
}
// Generated as internal constructor for term x64_roundpd.
pub fn constructor_x64_roundpd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: &RoundImm) -> Xmm {
    let v6 = C::use_avx_simd(ctx);
    if v6 == true {
        let v8 = C::encode_round_imm(ctx, arg1);
        let v9 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vroundpd, arg0, v8);
        // Rule at src/isa/x64/inst.isle line 3381.
        return v9;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = C::encode_round_imm(ctx, arg1);
    let v5 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Roundpd, v3, v4);
    // Rule at src/isa/x64/inst.isle line 3379.
    return v5;
}
// Generated as internal constructor for term x64_pmaddwd.
pub fn constructor_x64_pmaddwd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddwd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3389.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddwd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3387.
    return v4;
}
// Generated as internal constructor for term x64_pmaddubsw.
pub fn constructor_x64_pmaddubsw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpmaddubsw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3396.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pmaddubsw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3394.
    return v4;
}
// Generated as internal constructor for term x64_insertps.
pub fn constructor_x64_insertps<C: Context>(
    ctx: &mut C,
    arg0: Xmm,
    arg1: &XmmMem,
    arg2: u8,
) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vinsertps, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3408.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(
        ctx,
        &SseOpcode::Insertps,
        v4,
        v5,
        arg2,
        &OperandSize::Size32,
    );
    // Rule at src/isa/x64/inst.isle line 3402.
    return v7;
}
// Generated as internal constructor for term x64_pshufd.
pub fn constructor_x64_pshufd<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufd, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3416.
        return v7;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufd, v3, arg1);
    // Rule at src/isa/x64/inst.isle line 3414.
    return v4;
}
// Generated as internal constructor for term x64_pshufb.
pub fn constructor_x64_pshufb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpshufb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3424.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pshufb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3422.
    return v4;
}
// Generated as internal constructor for term x64_pshuflw.
pub fn constructor_x64_pshuflw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshuflw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3432.
        return v7;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshuflw, v3, arg1);
    // Rule at src/isa/x64/inst.isle line 3430.
    return v4;
}
// Generated as internal constructor for term x64_pshufhw.
pub fn constructor_x64_pshufhw<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: u8) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_unary_rm_r_imm_vex(ctx, &AvxOpcode::Vpshufhw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3440.
        return v7;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v4 = constructor_xmm_unary_rm_r_imm(ctx, &SseOpcode::Pshufhw, v3, arg1);
    // Rule at src/isa/x64/inst.isle line 3438.
    return v4;
}
// Generated as internal constructor for term x64_shufps.
pub fn constructor_x64_shufps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem, arg2: u8) -> Xmm {
    let v8 = C::use_avx_simd(ctx);
    if v8 == true {
        let v10 = constructor_xmm_rmr_imm_vex(ctx, &AvxOpcode::Vshufps, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3452.
        return v10;
    }
    let v4 = C::xmm_to_reg(ctx, arg0);
    let v5 = &C::xmm_mem_to_reg_mem(ctx, arg1);
    let v7 = constructor_xmm_rm_r_imm(ctx, &SseOpcode::Shufps, v4, v5, arg2, &OperandSize::Size32);
    // Rule at src/isa/x64/inst.isle line 3446.
    return v7;
}
// Generated as internal constructor for term xmm_unary_rm_r.
pub fn constructor_xmm_unary_rm_r<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &XmmMemAligned,
) -> Xmm {
    let v2 = C::temp_writable_xmm(ctx);
    let v3 = MInst::XmmUnaryRmR {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xmm_to_xmm(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3458.
    return v5;
}
// Generated as internal constructor for term xmm_unary_rm_r_unaligned.
pub fn constructor_xmm_unary_rm_r_unaligned<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::temp_writable_xmm(ctx);
    let v3 = MInst::XmmUnaryRmRUnaligned {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xmm_to_xmm(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3465.
    return v5;
}
// Generated as internal constructor for term x64_pabsb.
pub fn constructor_x64_pabsb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsb, arg0);
        // Rule at src/isa/x64/inst.isle line 3474.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsb, v2);
    // Rule at src/isa/x64/inst.isle line 3472.
    return v3;
}
// Generated as internal constructor for term x64_pabsw.
pub fn constructor_x64_pabsw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsw, arg0);
        // Rule at src/isa/x64/inst.isle line 3482.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsw, v2);
    // Rule at src/isa/x64/inst.isle line 3480.
    return v3;
}
// Generated as internal constructor for term x64_pabsd.
pub fn constructor_x64_pabsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpabsd, arg0);
        // Rule at src/isa/x64/inst.isle line 3490.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Pabsd, v2);
    // Rule at src/isa/x64/inst.isle line 3488.
    return v3;
}
// Generated as internal constructor for term xmm_unary_rm_r_evex.
pub fn constructor_xmm_unary_rm_r_evex<C: Context>(
    ctx: &mut C,
    arg0: &Avx512Opcode,
    arg1: &XmmMem,
) -> Xmm {
    let v2 = C::temp_writable_xmm(ctx);
    let v3 = MInst::XmmUnaryRmREvex {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_xmm_to_xmm(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3496.
    return v5;
}
// Generated as internal constructor for term x64_vcvtudq2ps.
pub fn constructor_x64_vcvtudq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vcvtudq2ps, arg0);
    // Rule at src/isa/x64/inst.isle line 3503.
    return v2;
}
// Generated as internal constructor for term x64_vpabsq.
pub fn constructor_x64_vpabsq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpabsq, arg0);
    // Rule at src/isa/x64/inst.isle line 3508.
    return v2;
}
// Generated as internal constructor for term x64_vpopcntb.
pub fn constructor_x64_vpopcntb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_evex(ctx, &Avx512Opcode::Vpopcntb, arg0);
    // Rule at src/isa/x64/inst.isle line 3513.
    return v2;
}
// Generated as internal constructor for term xmm_rm_r_evex.
pub fn constructor_xmm_rm_r_evex<C: Context>(
    ctx: &mut C,
    arg0: &Avx512Opcode,
    arg1: &XmmMem,
    arg2: Xmm,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmRmREvex {
        op: arg0.clone(),
        src1: arg1.clone(),
        src2: arg2,
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3518.
    return v6;
}
// Generated as internal constructor for term x64_vpmullq.
pub fn constructor_x64_vpmullq<C: Context>(ctx: &mut C, arg0: &XmmMem, arg1: Xmm) -> Xmm {
    let v3 = constructor_xmm_rm_r_evex(ctx, &Avx512Opcode::Vpmullq, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3530.
    return v3;
}
// Generated as internal constructor for term x64_vpermi2b.
pub fn constructor_x64_vpermi2b<C: Context>(ctx: &mut C, arg0: Xmm, arg1: Xmm, arg2: Xmm) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v5 = &C::xmm_to_xmm_mem(ctx, arg0);
    let v6 = MInst::XmmRmREvex3 {
        op: Avx512Opcode::Vpermi2b,
        src1: v5.clone(),
        src2: arg1,
        src3: arg2,
        dst: v3,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3539.
    return v8;
}
// Generated as internal constructor for term mul_hi.
pub fn constructor_mul_hi<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Gpr,
    arg3: &GprMem,
) -> ValueRegs {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = &C::raw_operand_size_of_type(ctx, arg0);
    let v7 = MInst::MulHi {
        size: v6.clone(),
        signed: arg1,
        src1: arg2,
        src2: arg3.clone(),
        dst_lo: v4,
        dst_hi: v5,
    };
    let v8 = C::emit(ctx, &v7);
    let v9 = C::writable_gpr_to_gpr(ctx, v4);
    let v10 = C::writable_gpr_to_gpr(ctx, v5);
    let v11 = constructor_value_gprs(ctx, v9, v10);
    // Rule at src/isa/x64/inst.isle line 3552.
    return v11;
}
// Generated as internal constructor for term mulhi_u.
pub fn constructor_mulhi_u<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: &GprMem,
) -> ValueRegs {
    let v4 = constructor_mul_hi(ctx, arg0, false, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 3567.
    return v4;
}
// Generated as internal constructor for term xmm_rmi_xmm.
pub fn constructor_xmm_rmi_xmm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: &XmmMemAlignedImm,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmRmiReg {
        opcode: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3572.
    return v6;
}
// Generated as internal constructor for term x64_psllw.
pub fn constructor_x64_psllw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3584.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3582.
    return v4;
}
// Generated as internal constructor for term x64_pslld.
pub fn constructor_x64_pslld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpslld, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3592.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Pslld, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3590.
    return v4;
}
// Generated as internal constructor for term x64_psllq.
pub fn constructor_x64_psllq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsllq, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3600.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psllq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3598.
    return v4;
}
// Generated as internal constructor for term x64_psrlw.
pub fn constructor_x64_psrlw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3608.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3606.
    return v4;
}
// Generated as internal constructor for term x64_psrld.
pub fn constructor_x64_psrld<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrld, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3616.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrld, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3614.
    return v4;
}
// Generated as internal constructor for term x64_psrlq.
pub fn constructor_x64_psrlq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrlq, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3624.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrlq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3622.
    return v4;
}
// Generated as internal constructor for term x64_psraw.
pub fn constructor_x64_psraw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsraw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3632.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psraw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3630.
    return v4;
}
// Generated as internal constructor for term x64_psrad.
pub fn constructor_x64_psrad<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMemImm) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpsrad, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3640.
        return v7;
    }
    let v3 = &C::xmm_mem_imm_to_xmm_mem_aligned_imm(ctx, arg1);
    let v4 = constructor_xmm_rmi_xmm(ctx, &SseOpcode::Psrad, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3638.
    return v4;
}
// Generated as internal constructor for term x64_pextrb.
pub fn constructor_x64_pextrb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3648.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrb, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3646.
    return v3;
}
// Generated as internal constructor for term x64_pextrb_store.
pub fn constructor_x64_pextrb_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrb, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3655.
        return v7.clone();
    }
    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrb, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 3653.
    return v4.clone();
}
// Generated as internal constructor for term x64_pextrw.
pub fn constructor_x64_pextrw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3663.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrw, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3661.
    return v3;
}
// Generated as internal constructor for term x64_pextrw_store.
pub fn constructor_x64_pextrw_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrw, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3670.
        return v7.clone();
    }
    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrw, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 3668.
    return v4.clone();
}
// Generated as internal constructor for term x64_pextrd.
pub fn constructor_x64_pextrd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3678.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3676.
    return v3;
}
// Generated as internal constructor for term x64_pextrd_store.
pub fn constructor_x64_pextrd_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrd, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3685.
        return v7.clone();
    }
    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrd, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 3683.
    return v4.clone();
}
// Generated as internal constructor for term x64_pextrq.
pub fn constructor_x64_pextrq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: u8) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1);
        // Rule at src/isa/x64/inst.isle line 3693.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr_imm(ctx, &SseOpcode::Pextrq, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3691.
    return v3;
}
// Generated as internal constructor for term x64_pextrq_store.
pub fn constructor_x64_pextrq_store<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
    arg1: Xmm,
    arg2: u8,
) -> SideEffectNoResult {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &constructor_xmm_movrm_imm_vex(ctx, &AvxOpcode::Vpextrq, arg0, arg1, arg2);
        // Rule at src/isa/x64/inst.isle line 3700.
        return v7.clone();
    }
    let v4 = &constructor_xmm_movrm_imm(ctx, &SseOpcode::Pextrq, arg0, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 3698.
    return v4.clone();
}
// Generated as internal constructor for term xmm_to_gpr.
pub fn constructor_xmm_to_gpr<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: &OperandSize,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = MInst::XmmToGpr {
        op: arg0.clone(),
        src: arg1,
        dst: v3,
        dst_size: arg2.clone(),
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3706.
    return v6;
}
// Generated as internal constructor for term xmm_to_gpr_imm.
pub fn constructor_xmm_to_gpr_imm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: Xmm,
    arg2: u8,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = MInst::XmmToGprImm {
        op: arg0.clone(),
        src: arg1,
        dst: v3,
        imm: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3713.
    return v6;
}
// Generated as internal constructor for term xmm_to_gpr_imm_vex.
pub fn constructor_xmm_to_gpr_imm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: u8,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = MInst::XmmToGprImmVex {
        op: arg0.clone(),
        src: arg1,
        dst: v3,
        imm: arg2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3720.
    return v6;
}
// Generated as internal constructor for term xmm_to_gpr_vex.
pub fn constructor_xmm_to_gpr_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: &OperandSize,
) -> Gpr {
    let v3 = C::temp_writable_gpr(ctx);
    let v4 = MInst::XmmToGprVex {
        op: arg0.clone(),
        src: arg1,
        dst: v3,
        dst_size: arg2.clone(),
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3727.
    return v6;
}
// Generated as internal constructor for term gpr_to_xmm_vex.
pub fn constructor_gpr_to_xmm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: &GprMem,
    arg2: &OperandSize,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::GprToXmmVex {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v3,
        src_size: arg2.clone(),
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3734.
    return v6;
}
// Generated as internal constructor for term x64_pmovmskb.
pub fn constructor_x64_pmovmskb<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vpmovmskb, arg1, arg0);
        // Rule at src/isa/x64/inst.isle line 3744.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Pmovmskb, arg1, arg0);
    // Rule at src/isa/x64/inst.isle line 3742.
    return v3;
}
// Generated as internal constructor for term x64_movmskps.
pub fn constructor_x64_movmskps<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskps, arg1, arg0);
        // Rule at src/isa/x64/inst.isle line 3752.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskps, arg1, arg0);
    // Rule at src/isa/x64/inst.isle line 3750.
    return v3;
}
// Generated as internal constructor for term x64_movmskpd.
pub fn constructor_x64_movmskpd<C: Context>(ctx: &mut C, arg0: &OperandSize, arg1: Xmm) -> Gpr {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_to_gpr_vex(ctx, &AvxOpcode::Vmovmskpd, arg1, arg0);
        // Rule at src/isa/x64/inst.isle line 3760.
        return v6;
    }
    let v3 = constructor_xmm_to_gpr(ctx, &SseOpcode::Movmskpd, arg1, arg0);
    // Rule at src/isa/x64/inst.isle line 3758.
    return v3;
}
// Generated as internal constructor for term gpr_to_xmm.
pub fn constructor_gpr_to_xmm<C: Context>(
    ctx: &mut C,
    arg0: &SseOpcode,
    arg1: &GprMem,
    arg2: &OperandSize,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::GprToXmm {
        op: arg0.clone(),
        src: arg1.clone(),
        dst: v3,
        src_size: arg2.clone(),
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3766.
    return v6;
}
// Generated as internal constructor for term x64_not.
pub fn constructor_x64_not<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v4 = MInst::Not {
        size: v3.clone(),
        src: arg1,
        dst: v2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3773.
    return v6;
}
// Generated as internal constructor for term x64_neg.
pub fn constructor_x64_neg<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::raw_operand_size_of_type(ctx, arg0);
    let v4 = MInst::Neg {
        size: v3.clone(),
        src: arg1,
        dst: v2,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3781.
    return v6;
}
// Generated as internal constructor for term x64_neg_paired.
pub fn constructor_x64_neg_paired<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::raw_operand_size_of_type(ctx, arg0);
    let v5 = constructor_writable_gpr_to_r_reg(ctx, v2);
    let v4 = MInst::Neg {
        size: v3.clone(),
        src: arg1,
        dst: v2,
    };
    let v6 = ProducesFlags::ProducesFlagsReturnsResultWithConsumer {
        inst: v4,
        result: v5,
    };
    // Rule at src/isa/x64/inst.isle line 3789.
    return v6;
}
// Generated as internal constructor for term x64_lea.
pub fn constructor_x64_lea<C: Context>(ctx: &mut C, arg0: Type, arg1: &SyntheticAmode) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v4 = MInst::LoadEffectiveAddress {
        addr: arg1.clone(),
        dst: v2,
        size: v3.clone(),
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3796.
    return v6;
}
// Generated as internal constructor for term x64_ud2.
pub fn constructor_x64_ud2<C: Context>(ctx: &mut C, arg0: &TrapCode) -> SideEffectNoResult {
    let v1 = MInst::Ud2 {
        trap_code: arg0.clone(),
    };
    let v2 = SideEffectNoResult::Inst { inst: v1 };
    // Rule at src/isa/x64/inst.isle line 3803.
    return v2;
}
// Generated as internal constructor for term x64_hlt.
pub fn constructor_x64_hlt<C: Context>(ctx: &mut C) -> SideEffectNoResult {
    let v1 = SideEffectNoResult::Inst { inst: MInst::Hlt };
    // Rule at src/isa/x64/inst.isle line 3808.
    return v1;
}
// Generated as internal constructor for term x64_lzcnt.
pub fn constructor_x64_lzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v6 = MInst::UnaryRmR {
        size: v3.clone(),
        op: UnaryRmROpcode::Lzcnt,
        src: v5.clone(),
        dst: v2,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3813.
    return v8;
}
// Generated as internal constructor for term x64_tzcnt.
pub fn constructor_x64_tzcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v6 = MInst::UnaryRmR {
        size: v3.clone(),
        op: UnaryRmROpcode::Tzcnt,
        src: v5.clone(),
        dst: v2,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3821.
    return v8;
}
// Generated as internal constructor for term x64_bsr.
pub fn constructor_x64_bsr<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);
    let v6 = MInst::UnaryRmR {
        size: v3.clone(),
        op: UnaryRmROpcode::Bsr,
        src: v5.clone(),
        dst: v2,
    };
    let v8 = ProducesFlags::ProducesFlagsReturnsReg {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 3829.
    return v8;
}
// Generated as internal constructor for term bsr_or_else.
pub fn constructor_bsr_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {
    let v3 = &constructor_x64_bsr(ctx, arg0, arg1);
    let v4 = constructor_produces_flags_get_reg(ctx, v3);
    let v5 = C::gpr_new(ctx, v4);
    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);
    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);
    let v9 = &constructor_produces_flags_ignore(ctx, v3);
    let v10 = constructor_with_flags_reg(ctx, v9, v8);
    let v11 = C::gpr_new(ctx, v10);
    // Rule at src/isa/x64/inst.isle line 3838.
    return v11;
}
// Generated as internal constructor for term x64_bsf.
pub fn constructor_x64_bsf<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> ProducesFlags {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v7 = constructor_writable_gpr_to_r_reg(ctx, v2);
    let v6 = MInst::UnaryRmR {
        size: v3.clone(),
        op: UnaryRmROpcode::Bsf,
        src: v5.clone(),
        dst: v2,
    };
    let v8 = ProducesFlags::ProducesFlagsReturnsReg {
        inst: v6,
        result: v7,
    };
    // Rule at src/isa/x64/inst.isle line 3849.
    return v8;
}
// Generated as internal constructor for term bsf_or_else.
pub fn constructor_bsf_or_else<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr, arg2: Gpr) -> Gpr {
    let v3 = &constructor_x64_bsf(ctx, arg0, arg1);
    let v4 = constructor_produces_flags_get_reg(ctx, v3);
    let v5 = C::gpr_new(ctx, v4);
    let v7 = &C::gpr_to_gpr_mem(ctx, arg2);
    let v8 = &constructor_cmove(ctx, arg0, &CC::Z, v7, v5);
    let v9 = &constructor_produces_flags_ignore(ctx, v3);
    let v10 = constructor_with_flags_reg(ctx, v9, v8);
    let v11 = C::gpr_new(ctx, v10);
    // Rule at src/isa/x64/inst.isle line 3858.
    return v11;
}
// Generated as internal constructor for term x64_popcnt.
pub fn constructor_x64_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::gpr_to_gpr_mem(ctx, arg1);
    let v6 = MInst::UnaryRmR {
        size: v3.clone(),
        op: UnaryRmROpcode::Popcnt,
        src: v5.clone(),
        dst: v2,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 3869.
    return v8;
}
// Generated as internal constructor for term xmm_min_max_seq.
pub fn constructor_xmm_min_max_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: bool,
    arg2: Xmm,
    arg3: Xmm,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v6 = MInst::XmmMinMaxSeq {
        size: v5.clone(),
        is_min: arg1,
        lhs: arg2,
        rhs: arg3,
        dst: v4,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3877.
    return v8;
}
// Generated as internal constructor for term x64_minss.
pub fn constructor_x64_minss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 3887.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3885.
    return v3;
}
// Generated as internal constructor for term x64_minsd.
pub fn constructor_x64_minsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 3895.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Minsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3893.
    return v3;
}
// Generated as internal constructor for term x64_minps.
pub fn constructor_x64_minps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3903.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3901.
    return v4;
}
// Generated as internal constructor for term x64_minpd.
pub fn constructor_x64_minpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vminpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3911.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Minpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3909.
    return v4;
}
// Generated as internal constructor for term x64_maxss.
pub fn constructor_x64_maxss<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxss, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 3919.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxss, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3917.
    return v3;
}
// Generated as internal constructor for term x64_maxsd.
pub fn constructor_x64_maxsd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v7 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxsd, arg0, v6);
        // Rule at src/isa/x64/inst.isle line 3927.
        return v7;
    }
    let v3 = constructor_xmm_rm_r_unaligned(ctx, &SseOpcode::Maxsd, arg0, arg1);
    // Rule at src/isa/x64/inst.isle line 3925.
    return v3;
}
// Generated as internal constructor for term x64_maxps.
pub fn constructor_x64_maxps<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxps, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3935.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxps, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3933.
    return v4;
}
// Generated as internal constructor for term x64_maxpd.
pub fn constructor_x64_maxpd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vmaxpd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 3943.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Maxpd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 3941.
    return v4;
}
// Generated as internal constructor for term xmm_rmir_vex.
pub fn constructor_xmm_rmir_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: &XmmMemImm,
) -> Xmm {
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = MInst::XmmRmiRVex {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v3,
    };
    let v5 = C::emit(ctx, &v4);
    let v6 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 3950.
    return v6;
}
// Generated as internal constructor for term xmm_rmr_imm_vex.
pub fn constructor_xmm_rmr_imm_vex<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: &XmmMem,
    arg3: u8,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = MInst::XmmRmRImmVex {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2.clone(),
        dst: v4,
        imm: arg3,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3957.
    return v7;
}
// Generated as internal constructor for term xmm_rmr_vex3.
pub fn constructor_xmm_rmr_vex3<C: Context>(
    ctx: &mut C,
    arg0: &AvxOpcode,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    let v4 = C::temp_writable_xmm(ctx);
    let v5 = MInst::XmmRmRVex3 {
        op: arg0.clone(),
        src1: arg1,
        src2: arg2,
        src3: arg3.clone(),
        dst: v4,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_xmm_to_xmm(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 3964.
    return v7;
}
// Generated as internal constructor for term x64_vfmadd213.
pub fn constructor_x64_vfmadd213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ss, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3971.
            return v5;
        }
        F64 => {
            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213sd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3972.
            return v7;
        }
        F32X4 => {
            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213ps, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3973.
            return v9;
        }
        F64X2 => {
            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd213pd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3974.
            return v11;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_vfmadd213", "src/isa/x64/inst.isle line 3970"
    )
}
// Generated as internal constructor for term x64_vfmadd132.
pub fn constructor_x64_vfmadd132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ss, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3978.
            return v5;
        }
        F64 => {
            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132sd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3979.
            return v7;
        }
        F32X4 => {
            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132ps, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3980.
            return v9;
        }
        F64X2 => {
            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfmadd132pd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3981.
            return v11;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_vfmadd132", "src/isa/x64/inst.isle line 3977"
    )
}
// Generated as internal constructor for term x64_vfnmadd213.
pub fn constructor_x64_vfnmadd213<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ss, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3985.
            return v5;
        }
        F64 => {
            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213sd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3986.
            return v7;
        }
        F32X4 => {
            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213ps, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3987.
            return v9;
        }
        F64X2 => {
            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd213pd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3988.
            return v11;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_vfnmadd213", "src/isa/x64/inst.isle line 3984"
    )
}
// Generated as internal constructor for term x64_vfnmadd132.
pub fn constructor_x64_vfnmadd132<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: Xmm,
    arg3: &XmmMem,
) -> Xmm {
    match arg0 {
        F32 => {
            let v5 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ss, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3992.
            return v5;
        }
        F64 => {
            let v7 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132sd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3993.
            return v7;
        }
        F32X4 => {
            let v9 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132ps, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3994.
            return v9;
        }
        F64X2 => {
            let v11 = constructor_xmm_rmr_vex3(ctx, &AvxOpcode::Vfnmadd132pd, arg1, arg2, arg3);
            // Rule at src/isa/x64/inst.isle line 3995.
            return v11;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_vfnmadd132", "src/isa/x64/inst.isle line 3991"
    )
}
// Generated as internal constructor for term x64_sqrtss.
pub fn constructor_x64_sqrtss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtss, arg0);
        // Rule at src/isa/x64/inst.isle line 4000.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtss, arg0);
    // Rule at src/isa/x64/inst.isle line 3999.
    return v2;
}
// Generated as internal constructor for term x64_sqrtsd.
pub fn constructor_x64_sqrtsd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtsd, arg0);
        // Rule at src/isa/x64/inst.isle line 4007.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Sqrtsd, arg0);
    // Rule at src/isa/x64/inst.isle line 4006.
    return v2;
}
// Generated as internal constructor for term x64_sqrtps.
pub fn constructor_x64_sqrtps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtps, arg0);
        // Rule at src/isa/x64/inst.isle line 4014.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtps, v2);
    // Rule at src/isa/x64/inst.isle line 4013.
    return v3;
}
// Generated as internal constructor for term x64_sqrtpd.
pub fn constructor_x64_sqrtpd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vsqrtpd, arg0);
        // Rule at src/isa/x64/inst.isle line 4021.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Sqrtpd, v2);
    // Rule at src/isa/x64/inst.isle line 4020.
    return v3;
}
// Generated as internal constructor for term x64_cvtss2sd.
pub fn constructor_x64_cvtss2sd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtss2sd, arg0);
        // Rule at src/isa/x64/inst.isle line 4028.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtss2sd, arg0);
    // Rule at src/isa/x64/inst.isle line 4027.
    return v2;
}
// Generated as internal constructor for term x64_cvtsd2ss.
pub fn constructor_x64_cvtsd2ss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtsd2ss, arg0);
        // Rule at src/isa/x64/inst.isle line 4035.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Cvtsd2ss, arg0);
    // Rule at src/isa/x64/inst.isle line 4034.
    return v2;
}
// Generated as internal constructor for term x64_cvtdq2ps.
pub fn constructor_x64_cvtdq2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2ps, arg0);
        // Rule at src/isa/x64/inst.isle line 4042.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2ps, v2);
    // Rule at src/isa/x64/inst.isle line 4041.
    return v3;
}
// Generated as internal constructor for term x64_cvtps2pd.
pub fn constructor_x64_cvtps2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtps2pd, arg0);
        // Rule at src/isa/x64/inst.isle line 4049.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtps2pd, v2);
    // Rule at src/isa/x64/inst.isle line 4048.
    return v3;
}
// Generated as internal constructor for term x64_cvtpd2ps.
pub fn constructor_x64_cvtpd2ps<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtpd2ps, arg0);
        // Rule at src/isa/x64/inst.isle line 4056.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtpd2ps, v2);
    // Rule at src/isa/x64/inst.isle line 4055.
    return v3;
}
// Generated as internal constructor for term x64_cvtdq2pd.
pub fn constructor_x64_cvtdq2pd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvtdq2pd, arg0);
        // Rule at src/isa/x64/inst.isle line 4063.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvtdq2pd, v2);
    // Rule at src/isa/x64/inst.isle line 4062.
    return v3;
}
// Generated as internal constructor for term x64_cvtsi2ss.
pub fn constructor_x64_cvtsi2ss<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v3 = &C::raw_operand_size_of_type(ctx, arg0);
        let v7 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vcvtsi2ss, arg1, v3);
        // Rule at src/isa/x64/inst.isle line 4071.
        return v7;
    }
    let v3 = &C::raw_operand_size_of_type(ctx, arg0);
    let v4 = constructor_gpr_to_xmm(ctx, &SseOpcode::Cvtsi2ss, arg1, v3);
    // Rule at src/isa/x64/inst.isle line 4069.
    return v4;
}
// Generated as internal constructor for term x64_cvtsi2sd.
pub fn constructor_x64_cvtsi2sd<C: Context>(ctx: &mut C, arg0: Type, arg1: &GprMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v3 = &C::raw_operand_size_of_type(ctx, arg0);
        let v7 = constructor_gpr_to_xmm_vex(ctx, &AvxOpcode::Vcvtsi2sd, arg1, v3);
        // Rule at src/isa/x64/inst.isle line 4079.
        return v7;
    }
    let v3 = &C::raw_operand_size_of_type(ctx, arg0);
    let v4 = constructor_gpr_to_xmm(ctx, &SseOpcode::Cvtsi2sd, arg1, v3);
    // Rule at src/isa/x64/inst.isle line 4077.
    return v4;
}
// Generated as internal constructor for term x64_cvttps2dq.
pub fn constructor_x64_cvttps2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttps2dq, arg0);
        // Rule at src/isa/x64/inst.isle line 4087.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttps2dq, v2);
    // Rule at src/isa/x64/inst.isle line 4085.
    return v3;
}
// Generated as internal constructor for term x64_cvttpd2dq.
pub fn constructor_x64_cvttpd2dq<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v4 = C::use_avx_simd(ctx);
    if v4 == true {
        let v6 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vcvttpd2dq, arg0);
        // Rule at src/isa/x64/inst.isle line 4095.
        return v6;
    }
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg0);
    let v3 = constructor_xmm_unary_rm_r(ctx, &SseOpcode::Cvttpd2dq, v2);
    // Rule at src/isa/x64/inst.isle line 4093.
    return v3;
}
// Generated as internal constructor for term cvt_u64_to_float_seq.
pub fn constructor_cvt_u64_to_float_seq<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {
    let v2 = &C::raw_operand_size_of_type(ctx, arg0);
    let v3 = C::temp_writable_xmm(ctx);
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = MInst::CvtUint64ToFloatSeq {
        dst_size: v2.clone(),
        src: arg1,
        dst: v3,
        tmp_gpr1: v4,
        tmp_gpr2: v5,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = C::writable_xmm_to_xmm(ctx, v3);
    // Rule at src/isa/x64/inst.isle line 4100.
    return v8;
}
// Generated as internal constructor for term cvt_float_to_uint_seq.
pub fn constructor_cvt_float_to_uint_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: bool,
) -> Gpr {
    let v4 = &C::raw_operand_size_of_type(ctx, arg0);
    let v2 = C::value_type(ctx, arg1);
    let v5 = &C::raw_operand_size_of_type(ctx, v2);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_xmm(ctx);
    let v8 = C::temp_writable_xmm(ctx);
    let v9 = C::temp_writable_gpr(ctx);
    let v10 = constructor_put_in_xmm(ctx, arg1);
    let v11 = MInst::CvtFloatToUintSeq {
        dst_size: v4.clone(),
        src_size: v5.clone(),
        is_saturating: arg2,
        src: v10,
        dst: v6,
        tmp_gpr: v9,
        tmp_xmm: v7,
        tmp_xmm2: v8,
    };
    let v12 = C::emit(ctx, &v11);
    let v13 = C::writable_gpr_to_gpr(ctx, v6);
    // Rule at src/isa/x64/inst.isle line 4109.
    return v13;
}
// Generated as internal constructor for term cvt_float_to_sint_seq.
pub fn constructor_cvt_float_to_sint_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: bool,
) -> Gpr {
    let v4 = &C::raw_operand_size_of_type(ctx, arg0);
    let v2 = C::value_type(ctx, arg1);
    let v5 = &C::raw_operand_size_of_type(ctx, v2);
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_xmm(ctx);
    let v8 = C::temp_writable_gpr(ctx);
    let v9 = constructor_put_in_xmm(ctx, arg1);
    let v10 = MInst::CvtFloatToSintSeq {
        dst_size: v4.clone(),
        src_size: v5.clone(),
        is_saturating: arg2,
        src: v9,
        dst: v6,
        tmp_gpr: v8,
        tmp_xmm: v7,
    };
    let v11 = C::emit(ctx, &v10);
    let v12 = C::writable_gpr_to_gpr(ctx, v6);
    // Rule at src/isa/x64/inst.isle line 4121.
    return v12;
}
// Generated as internal constructor for term x64_pcmpeq.
pub fn constructor_x64_pcmpeq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpeqb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4139.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpeqw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4140.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpeqd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4141.
            return v5;
        }
        I64X2 => {
            let v6 = constructor_x64_pcmpeqq(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4142.
            return v6;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pcmpeq", "src/isa/x64/inst.isle line 4138"
    )
}
// Generated as internal constructor for term x64_pcmpeqb.
pub fn constructor_x64_pcmpeqb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4146.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4145.
    return v4;
}
// Generated as internal constructor for term x64_pcmpeqw.
pub fn constructor_x64_pcmpeqw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4151.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4150.
    return v4;
}
// Generated as internal constructor for term x64_pcmpeqd.
pub fn constructor_x64_pcmpeqd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4156.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4155.
    return v4;
}
// Generated as internal constructor for term x64_pcmpeqq.
pub fn constructor_x64_pcmpeqq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpeqq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4161.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpeqq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4160.
    return v4;
}
// Generated as internal constructor for term x64_pcmpgt.
pub fn constructor_x64_pcmpgt<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v3 = constructor_x64_pcmpgtb(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4167.
            return v3;
        }
        I16X8 => {
            let v4 = constructor_x64_pcmpgtw(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4168.
            return v4;
        }
        I32X4 => {
            let v5 = constructor_x64_pcmpgtd(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4169.
            return v5;
        }
        I64X2 => {
            let v6 = constructor_x64_pcmpgtq(ctx, arg1, arg2);
            // Rule at src/isa/x64/inst.isle line 4170.
            return v6;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "x64_pcmpgt", "src/isa/x64/inst.isle line 4166"
    )
}
// Generated as internal constructor for term x64_pcmpgtb.
pub fn constructor_x64_pcmpgtb<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtb, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4174.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtb, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4173.
    return v4;
}
// Generated as internal constructor for term x64_pcmpgtw.
pub fn constructor_x64_pcmpgtw<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtw, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4179.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtw, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4178.
    return v4;
}
// Generated as internal constructor for term x64_pcmpgtd.
pub fn constructor_x64_pcmpgtd<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtd, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4184.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtd, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4183.
    return v4;
}
// Generated as internal constructor for term x64_pcmpgtq.
pub fn constructor_x64_pcmpgtq<C: Context>(ctx: &mut C, arg0: Xmm, arg1: &XmmMem) -> Xmm {
    let v5 = C::use_avx_simd(ctx);
    if v5 == true {
        let v7 = &C::xmm_mem_to_xmm_mem_imm(ctx, arg1);
        let v8 = constructor_xmm_rmir_vex(ctx, &AvxOpcode::Vpcmpgtq, arg0, v7);
        // Rule at src/isa/x64/inst.isle line 4189.
        return v8;
    }
    let v3 = &C::xmm_mem_to_xmm_mem_aligned(ctx, arg1);
    let v4 = constructor_xmm_rm_r(ctx, &SseOpcode::Pcmpgtq, arg0, v3);
    // Rule at src/isa/x64/inst.isle line 4188.
    return v4;
}
// Generated as internal constructor for term alu_rm.
pub fn constructor_alu_rm<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &AluRmiROpcode,
    arg2: &Amode,
    arg3: Gpr,
) -> SideEffectNoResult {
    let v4 = &C::operand_size_of_type_32_64(ctx, arg0);
    let v5 = &C::amode_to_synthetic_amode(ctx, arg2);
    let v6 = MInst::AluRM {
        size: v4.clone(),
        op: arg1.clone(),
        src1_dst: v5.clone(),
        src2: arg3,
    };
    let v7 = SideEffectNoResult::Inst { inst: v6 };
    // Rule at src/isa/x64/inst.isle line 4195.
    return v7;
}
// Generated as internal constructor for term x64_add_mem.
pub fn constructor_x64_add_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Amode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Add, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 4200.
    return v4.clone();
}
// Generated as internal constructor for term x64_sub_mem.
pub fn constructor_x64_sub_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Amode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Sub, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 4204.
    return v4.clone();
}
// Generated as internal constructor for term x64_and_mem.
pub fn constructor_x64_and_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Amode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::And, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 4208.
    return v4.clone();
}
// Generated as internal constructor for term x64_or_mem.
pub fn constructor_x64_or_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Amode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Or, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 4212.
    return v4.clone();
}
// Generated as internal constructor for term x64_xor_mem.
pub fn constructor_x64_xor_mem<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &Amode,
    arg2: Gpr,
) -> SideEffectNoResult {
    let v4 = &constructor_alu_rm(ctx, arg0, &AluRmiROpcode::Xor, arg1, arg2);
    // Rule at src/isa/x64/inst.isle line 4216.
    return v4.clone();
}
// Generated as internal constructor for term trap_if.
pub fn constructor_trap_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: &TrapCode) -> ConsumesFlags {
    let v2 = MInst::TrapIf {
        cc: arg0.clone(),
        trap_code: arg1.clone(),
    };
    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };
    // Rule at src/isa/x64/inst.isle line 4221.
    return v3;
}
// Generated as internal constructor for term trap_if_and.
pub fn constructor_trap_if_and<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &CC,
    arg2: &TrapCode,
) -> ConsumesFlags {
    let v3 = MInst::TrapIfAnd {
        cc1: arg0.clone(),
        cc2: arg1.clone(),
        trap_code: arg2.clone(),
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 4226.
    return v4;
}
// Generated as internal constructor for term trap_if_or.
pub fn constructor_trap_if_or<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: &CC,
    arg2: &TrapCode,
) -> ConsumesFlags {
    let v3 = MInst::TrapIfOr {
        cc1: arg0.clone(),
        cc2: arg1.clone(),
        trap_code: arg2.clone(),
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 4231.
    return v4;
}
// Generated as internal constructor for term trap_if_icmp.
pub fn constructor_trap_if_icmp<C: Context>(
    ctx: &mut C,
    arg0: &IcmpCondResult,
    arg1: &TrapCode,
) -> SideEffectNoResult {
    if let &IcmpCondResult::Condition {
        producer: ref v1,
        cc: ref v2,
    } = arg0
    {
        let v4 = &constructor_trap_if(ctx, v2, arg1);
        let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);
        // Rule at src/isa/x64/inst.isle line 4235.
        return v5.clone();
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "trap_if_icmp", "src/isa/x64/inst.isle line 4234"
    )
}
// Generated as internal constructor for term trap_if_fcmp.
pub fn constructor_trap_if_fcmp<C: Context>(
    ctx: &mut C,
    arg0: &FcmpCondResult,
    arg1: &TrapCode,
) -> SideEffectNoResult {
    match arg0 {
        &FcmpCondResult::Condition {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v4 = &constructor_trap_if(ctx, v2, arg1);
            let v5 = &constructor_with_flags_side_effect(ctx, v1, v4);
            // Rule at src/isa/x64/inst.isle line 4239.
            return v5.clone();
        }
        &FcmpCondResult::AndCondition {
            producer: ref v6,
            cc1: ref v7,
            cc2: ref v8,
        } => {
            let v9 = &constructor_trap_if_and(ctx, v7, v8, arg1);
            let v10 = &constructor_with_flags_side_effect(ctx, v6, v9);
            // Rule at src/isa/x64/inst.isle line 4241.
            return v10.clone();
        }
        &FcmpCondResult::OrCondition {
            producer: ref v11,
            cc1: ref v12,
            cc2: ref v13,
        } => {
            let v14 = &constructor_trap_if_or(ctx, v12, v13, arg1);
            let v15 = &constructor_with_flags_side_effect(ctx, v11, v14);
            // Rule at src/isa/x64/inst.isle line 4243.
            return v15.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "trap_if_fcmp", "src/isa/x64/inst.isle line 4238"
    )
}
// Generated as internal constructor for term x64_movddup.
pub fn constructor_x64_movddup<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v3 = C::use_avx_simd(ctx);
    if v3 == true {
        let v5 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vmovddup, arg0);
        // Rule at src/isa/x64/inst.isle line 4250.
        return v5;
    }
    let v2 = constructor_xmm_unary_rm_r_unaligned(ctx, &SseOpcode::Movddup, arg0);
    // Rule at src/isa/x64/inst.isle line 4248.
    return v2;
}
// Generated as internal constructor for term x64_vpbroadcastb.
pub fn constructor_x64_vpbroadcastb<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastb, arg0);
    // Rule at src/isa/x64/inst.isle line 4256.
    return v2;
}
// Generated as internal constructor for term x64_vpbroadcastw.
pub fn constructor_x64_vpbroadcastw<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastw, arg0);
    // Rule at src/isa/x64/inst.isle line 4261.
    return v2;
}
// Generated as internal constructor for term x64_vpbroadcastd.
pub fn constructor_x64_vpbroadcastd<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vpbroadcastd, arg0);
    // Rule at src/isa/x64/inst.isle line 4266.
    return v2;
}
// Generated as internal constructor for term x64_vbroadcastss.
pub fn constructor_x64_vbroadcastss<C: Context>(ctx: &mut C, arg0: &XmmMem) -> Xmm {
    let v2 = constructor_xmm_unary_rm_r_vex(ctx, &AvxOpcode::Vbroadcastss, arg0);
    // Rule at src/isa/x64/inst.isle line 4271.
    return v2;
}
// Generated as internal constructor for term jmp_known.
pub fn constructor_jmp_known<C: Context>(ctx: &mut C, arg0: MachLabel) -> SideEffectNoResult {
    let v1 = MInst::JmpKnown { dst: arg0 };
    let v2 = SideEffectNoResult::Inst { inst: v1 };
    // Rule at src/isa/x64/inst.isle line 4278.
    return v2;
}
// Generated as internal constructor for term jmp_if.
pub fn constructor_jmp_if<C: Context>(ctx: &mut C, arg0: &CC, arg1: MachLabel) -> ConsumesFlags {
    let v2 = MInst::JmpIf {
        cc: arg0.clone(),
        taken: arg1,
    };
    let v3 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v2 };
    // Rule at src/isa/x64/inst.isle line 4282.
    return v3;
}
// Generated as internal constructor for term jmp_cond.
pub fn constructor_jmp_cond<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: MachLabel,
    arg2: MachLabel,
) -> ConsumesFlags {
    let v3 = MInst::JmpCond {
        cc: arg0.clone(),
        taken: arg1,
        not_taken: arg2,
    };
    let v4 = ConsumesFlags::ConsumesFlagsSideEffect { inst: v3 };
    // Rule at src/isa/x64/inst.isle line 4287.
    return v4;
}
// Generated as internal constructor for term jmp_cond_icmp.
pub fn constructor_jmp_cond_icmp<C: Context>(
    ctx: &mut C,
    arg0: &IcmpCondResult,
    arg1: MachLabel,
    arg2: MachLabel,
) -> SideEffectNoResult {
    if let &IcmpCondResult::Condition {
        producer: ref v1,
        cc: ref v2,
    } = arg0
    {
        let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);
        let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);
        // Rule at src/isa/x64/inst.isle line 4292.
        return v6.clone();
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "jmp_cond_icmp", "src/isa/x64/inst.isle line 4291"
    )
}
// Generated as internal constructor for term jmp_cond_fcmp.
pub fn constructor_jmp_cond_fcmp<C: Context>(
    ctx: &mut C,
    arg0: &FcmpCondResult,
    arg1: MachLabel,
    arg2: MachLabel,
) -> SideEffectNoResult {
    match arg0 {
        &FcmpCondResult::Condition {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v5 = &constructor_jmp_cond(ctx, v2, arg1, arg2);
            let v6 = &constructor_with_flags_side_effect(ctx, v1, v5);
            // Rule at src/isa/x64/inst.isle line 4297.
            return v6.clone();
        }
        &FcmpCondResult::AndCondition {
            producer: ref v7,
            cc1: ref v8,
            cc2: ref v9,
        } => {
            let v10 = &C::cc_invert(ctx, v8);
            let v11 = &constructor_jmp_if(ctx, v10, arg2);
            let v12 = &C::cc_invert(ctx, v9);
            let v13 = &constructor_jmp_cond(ctx, v12, arg2, arg1);
            let v14 = &constructor_consumes_flags_concat(ctx, v11, v13);
            let v15 = &constructor_with_flags_side_effect(ctx, v7, v14);
            // Rule at src/isa/x64/inst.isle line 4299.
            return v15.clone();
        }
        &FcmpCondResult::OrCondition {
            producer: ref v16,
            cc1: ref v17,
            cc2: ref v18,
        } => {
            let v19 = &constructor_jmp_if(ctx, v17, arg1);
            let v20 = &constructor_jmp_cond(ctx, v18, arg1, arg2);
            let v21 = &constructor_consumes_flags_concat(ctx, v19, v20);
            let v22 = &constructor_with_flags_side_effect(ctx, v16, v21);
            // Rule at src/isa/x64/inst.isle line 4304.
            return v22.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "jmp_cond_fcmp", "src/isa/x64/inst.isle line 4296"
    )
}
// Generated as internal constructor for term jmp_table_seq.
pub fn constructor_jmp_table_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: MachLabel,
    arg3: &BoxVecMachLabel,
) -> SideEffectNoResult {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::gpr_to_reg(ctx, arg1);
    let v7 = C::writable_gpr_to_reg(ctx, v4);
    let v8 = C::writable_gpr_to_reg(ctx, v5);
    let v9 = MInst::JmpTableSeq {
        idx: v6,
        tmp1: v7,
        tmp2: v8,
        default_target: arg2,
        targets: arg3.clone(),
    };
    let v10 = SideEffectNoResult::Inst { inst: v9 };
    // Rule at src/isa/x64/inst.isle line 4324.
    return v10;
}
// Generated as internal constructor for term icmp_cond_result.
pub fn constructor_icmp_cond_result<C: Context>(
    ctx: &mut C,
    arg0: &ProducesFlags,
    arg1: &CC,
) -> IcmpCondResult {
    let v2 = IcmpCondResult::Condition {
        producer: arg0.clone(),
        cc: arg1.clone(),
    };
    // Rule at src/isa/x64/inst.isle line 4362.
    return v2;
}
// Generated as internal constructor for term invert_icmp_cond_result.
pub fn constructor_invert_icmp_cond_result<C: Context>(
    ctx: &mut C,
    arg0: &IcmpCondResult,
) -> IcmpCondResult {
    if let &IcmpCondResult::Condition {
        producer: ref v1,
        cc: ref v2,
    } = arg0
    {
        let v3 = &C::cc_invert(ctx, v2);
        let v4 = &constructor_icmp_cond_result(ctx, v1, v3);
        // Rule at src/isa/x64/inst.isle line 4365.
        return v4.clone();
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "invert_icmp_cond_result", "src/isa/x64/inst.isle line 4364"
    )
}
// Generated as internal constructor for term lower_icmp_bool.
pub fn constructor_lower_icmp_bool<C: Context>(ctx: &mut C, arg0: &IcmpCondResult) -> ValueRegs {
    if let &IcmpCondResult::Condition {
        producer: ref v1,
        cc: ref v2,
    } = arg0
    {
        let v3 = &constructor_x64_setcc(ctx, v2);
        let v4 = constructor_with_flags(ctx, v1, v3);
        // Rule at src/isa/x64/inst.isle line 4370.
        return v4;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "lower_icmp_bool", "src/isa/x64/inst.isle line 4369"
    )
}
// Generated as internal constructor for term select_icmp.
pub fn constructor_select_icmp<C: Context>(
    ctx: &mut C,
    arg0: &IcmpCondResult,
    arg1: Value,
    arg2: Value,
) -> ValueRegs {
    if let &IcmpCondResult::Condition {
        producer: ref v1,
        cc: ref v2,
    } = arg0
    {
        let v4 = C::value_type(ctx, arg1);
        let v5 = &C::type_register_class(ctx, v4);
        if let Some(v6) = v5 {
            if let &RegisterClass::Gpr {
                single_register: v7,
            } = v6
            {
                if v7 == true {
                    let v9 = constructor_put_in_gpr(ctx, arg1);
                    let v10 = &C::gpr_to_gpr_mem(ctx, v9);
                    let v11 = constructor_put_in_gpr(ctx, arg2);
                    let v12 = &constructor_cmove(ctx, v4, v2, v10, v11);
                    let v13 = constructor_with_flags(ctx, v1, v12);
                    // Rule at src/isa/x64/inst.isle line 4379.
                    return v13;
                }
            }
        }
        let v14 = &constructor_cmove_from_values(ctx, v4, v2, arg1, arg2);
        let v15 = constructor_with_flags(ctx, v1, v14);
        // Rule at src/isa/x64/inst.isle line 4383.
        return v15;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "select_icmp", "src/isa/x64/inst.isle line 4374"
    )
}
// Generated as internal constructor for term emit_cmp.
pub fn constructor_emit_cmp<C: Context>(
    ctx: &mut C,
    arg0: &IntCC,
    arg1: Value,
    arg2: Value,
) -> IcmpCondResult {
    let v2 = C::value_type(ctx, arg1);
    if v2 == I128 {
        match arg0 {
            &IntCC::Equal => {
                let v44 = C::put_in_regs(ctx, arg1);
                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);
                let v47 = C::put_in_regs(ctx, arg1);
                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);
                let v50 = C::put_in_regs(ctx, arg2);
                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);
                let v52 = C::put_in_regs(ctx, arg2);
                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);
                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);
                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);
                let v58 = &constructor_x64_setcc(ctx, &CC::Z);
                let v59 = constructor_with_flags_reg(ctx, v56, v58);
                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);
                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);
                let v62 = &constructor_x64_setcc(ctx, &CC::Z);
                let v63 = constructor_with_flags_reg(ctx, v61, v62);
                let v65 = C::gpr_new(ctx, v59);
                let v66 = &constructor_reg_to_gpr_mem_imm(ctx, v63);
                let v67 = constructor_x64_and(ctx, I64, v65, v66);
                let v68 = C::gpr_to_reg(ctx, v67);
                let v70 = RegMemImm::Imm { simm32: 0x1 };
                let v71 = &C::gpr_mem_imm_new(ctx, &v70);
                let v72 = C::gpr_new(ctx, v68);
                let v73 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v72);
                let v75 = &constructor_icmp_cond_result(ctx, v73, &CC::NZ);
                // Rule at src/isa/x64/inst.isle line 4415.
                return v75.clone();
            }
            &IntCC::NotEqual => {
                let v44 = C::put_in_regs(ctx, arg1);
                let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);
                let v47 = C::put_in_regs(ctx, arg1);
                let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);
                let v50 = C::put_in_regs(ctx, arg2);
                let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);
                let v52 = C::put_in_regs(ctx, arg2);
                let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);
                let v55 = &C::gpr_to_gpr_mem_imm(ctx, v51);
                let v56 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v55, v46);
                let v76 = &constructor_x64_setcc(ctx, &CC::NZ);
                let v77 = constructor_with_flags_reg(ctx, v56, v76);
                let v60 = &C::gpr_to_gpr_mem_imm(ctx, v53);
                let v61 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v60, v49);
                let v78 = &constructor_x64_setcc(ctx, &CC::NZ);
                let v79 = constructor_with_flags_reg(ctx, v61, v78);
                let v80 = C::gpr_new(ctx, v77);
                let v81 = &constructor_reg_to_gpr_mem_imm(ctx, v79);
                let v82 = constructor_x64_or(ctx, I64, v80, v81);
                let v83 = C::gpr_to_reg(ctx, v82);
                let v70 = RegMemImm::Imm { simm32: 0x1 };
                let v71 = &C::gpr_mem_imm_new(ctx, &v70);
                let v84 = C::gpr_new(ctx, v83);
                let v85 = &constructor_x64_test(ctx, &OperandSize::Size64, v71, v84);
                let v86 = &constructor_icmp_cond_result(ctx, v85, &CC::NZ);
                // Rule at src/isa/x64/inst.isle line 4436.
                return v86.clone();
            }
            _ => {}
        }
        let v44 = C::put_in_regs(ctx, arg1);
        let v46 = constructor_value_regs_get_gpr(ctx, v44, 0x0);
        let v47 = C::put_in_regs(ctx, arg1);
        let v49 = constructor_value_regs_get_gpr(ctx, v47, 0x1);
        let v50 = C::put_in_regs(ctx, arg2);
        let v51 = constructor_value_regs_get_gpr(ctx, v50, 0x0);
        let v52 = C::put_in_regs(ctx, arg2);
        let v53 = constructor_value_regs_get_gpr(ctx, v52, 0x1);
        let v87 = &C::gpr_to_gpr_mem_imm(ctx, v53);
        let v88 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v87, v49);
        let v89 = &C::intcc_without_eq(ctx, arg0);
        let v90 = &C::intcc_to_cc(ctx, v89);
        let v91 = &constructor_x64_setcc(ctx, v90);
        let v92 = &constructor_x64_setcc(ctx, &CC::Z);
        let v93 = &constructor_consumes_flags_concat(ctx, v91, v92);
        let v94 = constructor_with_flags(ctx, v88, v93);
        let v95 = C::value_regs_get(ctx, v94, 0x0);
        let v96 = C::value_regs_get(ctx, v94, 0x1);
        let v97 = &C::gpr_to_gpr_mem_imm(ctx, v51);
        let v98 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v97, v46);
        let v99 = &C::intcc_unsigned(ctx, arg0);
        let v100 = &C::intcc_to_cc(ctx, v99);
        let v101 = &constructor_x64_setcc(ctx, v100);
        let v102 = constructor_with_flags_reg(ctx, v98, v101);
        let v103 = C::gpr_new(ctx, v96);
        let v104 = &constructor_reg_to_gpr_mem_imm(ctx, v102);
        let v105 = constructor_x64_and(ctx, I64, v103, v104);
        let v106 = C::gpr_to_reg(ctx, v105);
        let v107 = C::gpr_new(ctx, v95);
        let v108 = &constructor_reg_to_gpr_mem_imm(ctx, v106);
        let v109 = constructor_x64_or(ctx, I64, v107, v108);
        let v110 = C::gpr_to_reg(ctx, v109);
        let v70 = RegMemImm::Imm { simm32: 0x1 };
        let v111 = &C::gpr_mem_imm_new(ctx, &v70);
        let v112 = C::gpr_new(ctx, v110);
        let v113 = &constructor_x64_test(ctx, &OperandSize::Size64, v111, v112);
        let v114 = &constructor_icmp_cond_result(ctx, v113, &CC::NZ);
        // Rule at src/isa/x64/inst.isle line 4451.
        return v114.clone();
    }
    let v29 = C::def_inst(ctx, arg1);
    if let Some(v30) = v29 {
        let v31 = &C::inst_data(ctx, v30);
        if let &InstructionData::UnaryImm {
            opcode: ref v32,
            imm: v33,
        } = v31
        {
            if let &Opcode::Iconst = v32 {
                let v34 = C::u64_from_imm64(ctx, v33);
                if v34 == 0x0 {
                    let v35 = C::value_type(ctx, arg2);
                    let v36 = &C::raw_operand_size_of_type(ctx, v35);
                    let v37 = C::put_in_reg(ctx, arg2);
                    let v38 = C::gpr_new(ctx, v37);
                    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);
                    let v40 = &constructor_x64_test(ctx, v36, v39, v38);
                    let v41 = &C::intcc_reverse(ctx, arg0);
                    let v42 = &C::intcc_to_cc(ctx, v41);
                    let v43 = &constructor_icmp_cond_result(ctx, v40, v42);
                    // Rule at src/isa/x64/inst.isle line 4408.
                    return v43.clone();
                }
            }
        }
    }
    let v17 = C::def_inst(ctx, arg2);
    if let Some(v18) = v17 {
        let v19 = &C::inst_data(ctx, v18);
        if let &InstructionData::UnaryImm {
            opcode: ref v20,
            imm: v21,
        } = v19
        {
            if let &Opcode::Iconst = v20 {
                let v22 = C::u64_from_imm64(ctx, v21);
                if v22 == 0x0 {
                    let v4 = &C::raw_operand_size_of_type(ctx, v2);
                    let v23 = C::put_in_reg(ctx, arg1);
                    let v24 = C::gpr_new(ctx, v23);
                    let v25 = &C::gpr_to_gpr_mem_imm(ctx, v24);
                    let v26 = &constructor_x64_test(ctx, v4, v25, v24);
                    let v27 = &C::intcc_to_cc(ctx, arg0);
                    let v28 = &constructor_icmp_cond_result(ctx, v26, v27);
                    // Rule at src/isa/x64/inst.isle line 4403.
                    return v28.clone();
                }
            }
        }
    }
    let v10 = &C::simm32_from_value(ctx, arg1);
    if let Some(v11) = v10 {
        let v4 = &C::raw_operand_size_of_type(ctx, v2);
        let v12 = constructor_put_in_gpr(ctx, arg2);
        let v13 = &constructor_x64_cmp(ctx, v4, v11, v12);
        let v14 = &C::intcc_reverse(ctx, arg0);
        let v15 = &C::intcc_to_cc(ctx, v14);
        let v16 = &constructor_icmp_cond_result(ctx, v13, v15);
        // Rule at src/isa/x64/inst.isle line 4398.
        return v16.clone();
    }
    let v4 = &C::raw_operand_size_of_type(ctx, v2);
    let v5 = &constructor_put_in_gpr_mem_imm(ctx, arg2);
    let v6 = constructor_put_in_gpr(ctx, arg1);
    let v7 = &constructor_x64_cmp(ctx, v4, v5, v6);
    let v8 = &C::intcc_to_cc(ctx, arg0);
    let v9 = &constructor_icmp_cond_result(ctx, v7, v8);
    // Rule at src/isa/x64/inst.isle line 4391.
    return v9.clone();
}
// Generated as internal constructor for term lower_fcmp_bool.
pub fn constructor_lower_fcmp_bool<C: Context>(ctx: &mut C, arg0: &FcmpCondResult) -> ValueRegs {
    match arg0 {
        &FcmpCondResult::Condition {
            producer: ref v1,
            cc: ref v2,
        } => {
            let v3 = &constructor_x64_setcc(ctx, v2);
            let v4 = constructor_with_flags(ctx, v1, v3);
            // Rule at src/isa/x64/inst.isle line 4486.
            return v4;
        }
        &FcmpCondResult::AndCondition {
            producer: ref v5,
            cc1: ref v6,
            cc2: ref v7,
        } => {
            let v8 = &constructor_x64_setcc(ctx, v6);
            let v9 = &constructor_x64_setcc(ctx, v7);
            let v10 = &constructor_consumes_flags_concat(ctx, v8, v9);
            let v11 = constructor_with_flags(ctx, v5, v10);
            let v13 = constructor_value_regs_get_gpr(ctx, v11, 0x0);
            let v15 = constructor_value_regs_get_gpr(ctx, v11, 0x1);
            let v17 = &C::gpr_to_gpr_mem_imm(ctx, v15);
            let v18 = constructor_x64_and(ctx, I8, v13, v17);
            let v19 = C::gpr_to_reg(ctx, v18);
            let v20 = C::value_reg(ctx, v19);
            // Rule at src/isa/x64/inst.isle line 4489.
            return v20;
        }
        &FcmpCondResult::OrCondition {
            producer: ref v21,
            cc1: ref v22,
            cc2: ref v23,
        } => {
            let v24 = &constructor_x64_setcc(ctx, v22);
            let v25 = &constructor_x64_setcc(ctx, v23);
            let v26 = &constructor_consumes_flags_concat(ctx, v24, v25);
            let v27 = constructor_with_flags(ctx, v21, v26);
            let v28 = constructor_value_regs_get_gpr(ctx, v27, 0x0);
            let v29 = constructor_value_regs_get_gpr(ctx, v27, 0x1);
            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);
            let v31 = constructor_x64_or(ctx, I8, v28, v30);
            let v32 = C::gpr_to_reg(ctx, v31);
            let v33 = C::value_reg(ctx, v32);
            // Rule at src/isa/x64/inst.isle line 4498.
            return v33;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "lower_fcmp_bool", "src/isa/x64/inst.isle line 4484"
    )
}
// Generated as internal constructor for term emit_fcmp.
pub fn constructor_emit_fcmp<C: Context>(
    ctx: &mut C,
    arg0: &FloatCC,
    arg1: Value,
    arg2: Value,
) -> FcmpCondResult {
    match arg0 {
        &FloatCC::Equal => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v9 = FcmpCondResult::AndCondition {
                    producer: v6.clone(),
                    cc1: CC::NP,
                    cc2: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 4525.
                return v9;
            }
        }
        &FloatCC::GreaterThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v18 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 4541.
                return v18;
            }
        }
        &FloatCC::GreaterThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v20 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 4543.
                return v20;
            }
        }
        &FloatCC::LessThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);
                let v26 = FcmpCondResult::Condition {
                    producer: v25.clone(),
                    cc: CC::NBE,
                };
                // Rule at src/isa/x64/inst.isle line 4553.
                return v26;
            }
        }
        &FloatCC::LessThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);
                let v27 = FcmpCondResult::Condition {
                    producer: v25.clone(),
                    cc: CC::NB,
                };
                // Rule at src/isa/x64/inst.isle line 4556.
                return v27;
            }
        }
        &FloatCC::NotEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v12 = FcmpCondResult::OrCondition {
                    producer: v6.clone(),
                    cc1: CC::P,
                    cc2: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 4528.
                return v12;
            }
        }
        &FloatCC::Ordered => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v13 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::NP,
                };
                // Rule at src/isa/x64/inst.isle line 4533.
                return v13;
            }
        }
        &FloatCC::OrderedNotEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v15 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::NZ,
                };
                // Rule at src/isa/x64/inst.isle line 4537.
                return v15;
            }
        }
        &FloatCC::Unordered => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v14 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::P,
                };
                // Rule at src/isa/x64/inst.isle line 4535.
                return v14;
            }
        }
        &FloatCC::UnorderedOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v16 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::Z,
                };
                // Rule at src/isa/x64/inst.isle line 4539.
                return v16;
            }
        }
        &FloatCC::UnorderedOrGreaterThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);
                let v28 = FcmpCondResult::Condition {
                    producer: v25.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 4559.
                return v28;
            }
        }
        &FloatCC::UnorderedOrGreaterThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v25 = &constructor_x64_ucomis(ctx, arg1, arg2);
                let v29 = FcmpCondResult::Condition {
                    producer: v25.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 4562.
                return v29;
            }
        }
        &FloatCC::UnorderedOrLessThan => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v22 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::B,
                };
                // Rule at src/isa/x64/inst.isle line 4545.
                return v22;
            }
        }
        &FloatCC::UnorderedOrLessThanOrEqual => {
            let v2 = C::value_type(ctx, arg1);
            let v3 = C::ty_scalar_float(ctx, v2);
            if let Some(v4) = v3 {
                let v6 = &constructor_x64_ucomis(ctx, arg2, arg1);
                let v24 = FcmpCondResult::Condition {
                    producer: v6.clone(),
                    cc: CC::BE,
                };
                // Rule at src/isa/x64/inst.isle line 4547.
                return v24;
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "emit_fcmp", "src/isa/x64/inst.isle line 4523"
    )
}
// Generated as internal constructor for term x64_mfence.
pub fn constructor_x64_mfence<C: Context>(ctx: &mut C) -> SideEffectNoResult {
    let v1 = MInst::Fence {
        kind: FenceKind::MFence,
    };
    let v2 = SideEffectNoResult::Inst { inst: v1 };
    // Rule at src/isa/x64/inst.isle line 4575.
    return v2;
}
// Generated as internal constructor for term x64_cmpxchg.
pub fn constructor_x64_cmpxchg<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Gpr,
    arg2: Gpr,
    arg3: &SyntheticAmode,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::gpr_to_reg(ctx, arg2);
    let v6 = C::gpr_to_reg(ctx, arg1);
    let v7 = C::writable_gpr_to_reg(ctx, v4);
    let v8 = MInst::LockCmpxchg {
        ty: arg0,
        replacement: v5,
        expected: v6,
        mem: arg3.clone(),
        dst_old: v7,
    };
    let v9 = C::emit(ctx, &v8);
    let v10 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 4579.
    return v10;
}
// Generated as internal constructor for term x64_atomic_rmw_seq.
pub fn constructor_x64_atomic_rmw_seq<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &MachAtomicRmwOp,
    arg2: &SyntheticAmode,
    arg3: Gpr,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = C::gpr_to_reg(ctx, arg3);
    let v7 = C::writable_gpr_to_reg(ctx, v5);
    let v8 = C::writable_gpr_to_reg(ctx, v4);
    let v9 = MInst::AtomicRmwSeq {
        ty: arg0,
        op: arg1.clone(),
        mem: arg2.clone(),
        operand: v6,
        temp: v7,
        dst_old: v8,
    };
    let v10 = C::emit(ctx, &v9);
    let v11 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 4585.
    return v11;
}
// Generated as internal constructor for term bitcast_xmm_to_gpr.
pub fn constructor_bitcast_xmm_to_gpr<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm) -> Gpr {
    match arg0 {
        F32 => {
            let v2 = constructor_x64_movd_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 4600.
            return v2;
        }
        F64 => {
            let v3 = constructor_x64_movq_to_gpr(ctx, arg1);
            // Rule at src/isa/x64/inst.isle line 4602.
            return v3;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "bitcast_xmm_to_gpr", "src/isa/x64/inst.isle line 4599"
    )
}
// Generated as internal constructor for term bitcast_gpr_to_xmm.
pub fn constructor_bitcast_gpr_to_xmm<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Xmm {
    match arg0 {
        I32 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v3 = constructor_x64_movd_to_xmm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 4606.
            return v3;
        }
        I64 => {
            let v2 = &C::gpr_to_gpr_mem(ctx, arg1);
            let v4 = constructor_x64_movq_to_xmm(ctx, v2);
            // Rule at src/isa/x64/inst.isle line 4608.
            return v4;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "bitcast_gpr_to_xmm", "src/isa/x64/inst.isle line 4605"
    )
}
// Generated as internal constructor for term stack_addr_impl.
pub fn constructor_stack_addr_impl<C: Context>(
    ctx: &mut C,
    arg0: StackSlot,
    arg1: Offset32,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = C::writable_gpr_to_reg(ctx, v2);
    let v4 = &C::abi_stackslot_addr(ctx, v3, arg0, arg1);
    let v5 = C::emit(ctx, v4);
    let v6 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 4614.
    return v6;
}
// Generated as internal constructor for term x64_checked_srem_seq.
pub fn constructor_x64_checked_srem_seq<C: Context>(
    ctx: &mut C,
    arg0: &OperandSize,
    arg1: Gpr,
    arg2: Gpr,
    arg3: Gpr,
) -> ValueRegs {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = C::temp_writable_gpr(ctx);
    let v6 = MInst::CheckedSRemSeq {
        size: arg0.clone(),
        dividend_lo: arg1,
        dividend_hi: arg2,
        divisor: arg3,
        dst_quotient: v4,
        dst_remainder: v5,
    };
    let v7 = C::emit(ctx, &v6);
    let v8 = constructor_writable_gpr_to_r_reg(ctx, v4);
    let v9 = constructor_writable_gpr_to_r_reg(ctx, v5);
    let v10 = C::value_regs(ctx, v8, v9);
    // Rule at src/isa/x64/inst.isle line 4623.
    return v10;
}
// Generated as internal constructor for term x64_checked_srem_seq8.
pub fn constructor_x64_checked_srem_seq8<C: Context>(ctx: &mut C, arg0: Gpr, arg1: Gpr) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::CheckedSRemSeq8 {
        dividend: arg0,
        divisor: arg1,
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 4630.
    return v5;
}
// Generated as internal constructor for term x64_div8.
pub fn constructor_x64_div8<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &GprMem,
    arg2: &DivSignedness,
    arg3: &TrapCode,
) -> Gpr {
    let v4 = C::temp_writable_gpr(ctx);
    let v5 = MInst::Div8 {
        sign: arg2.clone(),
        trap: arg3.clone(),
        divisor: arg1.clone(),
        dividend: arg0,
        dst: v4,
    };
    let v6 = C::emit(ctx, &v5);
    let v7 = C::writable_gpr_to_gpr(ctx, v4);
    // Rule at src/isa/x64/inst.isle line 4637.
    return v7;
}
// Generated as internal constructor for term x64_div.
pub fn constructor_x64_div<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &OperandSize,
    arg4: &DivSignedness,
    arg5: &TrapCode,
) -> ValueRegs {
    let v6 = C::temp_writable_gpr(ctx);
    let v7 = C::temp_writable_gpr(ctx);
    let v8 = MInst::Div {
        size: arg3.clone(),
        sign: arg4.clone(),
        trap: arg5.clone(),
        divisor: arg2.clone(),
        dividend_lo: arg0,
        dividend_hi: arg1,
        dst_quotient: v6,
        dst_remainder: v7,
    };
    let v9 = C::emit(ctx, &v8);
    let v10 = constructor_writable_gpr_to_r_reg(ctx, v6);
    let v11 = constructor_writable_gpr_to_r_reg(ctx, v7);
    let v12 = C::value_regs(ctx, v10, v11);
    // Rule at src/isa/x64/inst.isle line 4647.
    return v12;
}
// Generated as internal constructor for term x64_div_quotient.
pub fn constructor_x64_div_quotient<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &OperandSize,
    arg4: &DivSignedness,
    arg5: &TrapCode,
) -> ValueRegs {
    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);
    let v8 = C::value_regs_get(ctx, v6, 0x0);
    let v9 = C::value_reg(ctx, v8);
    // Rule at src/isa/x64/inst.isle line 4655.
    return v9;
}
// Generated as internal constructor for term x64_div_remainder.
pub fn constructor_x64_div_remainder<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: Gpr,
    arg2: &GprMem,
    arg3: &OperandSize,
    arg4: &DivSignedness,
    arg5: &TrapCode,
) -> ValueRegs {
    let v6 = constructor_x64_div(ctx, arg0, arg1, arg2, arg3, arg4, arg5);
    let v8 = C::value_regs_get(ctx, v6, 0x1);
    let v9 = C::value_reg(ctx, v8);
    // Rule at src/isa/x64/inst.isle line 4660.
    return v9;
}
// Generated as internal constructor for term x64_sign_extend_data.
pub fn constructor_x64_sign_extend_data<C: Context>(
    ctx: &mut C,
    arg0: Gpr,
    arg1: &OperandSize,
) -> Gpr {
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::SignExtendData {
        size: arg1.clone(),
        src: arg0,
        dst: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v2);
    // Rule at src/isa/x64/inst.isle line 4665.
    return v5;
}
// Generated as internal constructor for term read_pinned_gpr.
pub fn constructor_read_pinned_gpr<C: Context>(ctx: &mut C) -> Gpr {
    let v0 = C::preg_pinned(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    let v2 = C::gpr_new(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4673.
    return v2;
}
// Generated as internal constructor for term write_pinned_gpr.
pub fn constructor_write_pinned_gpr<C: Context>(ctx: &mut C, arg0: Gpr) -> SideEffectNoResult {
    let v1 = C::preg_pinned(ctx);
    let v2 = &constructor_mov_to_preg(ctx, v1, arg0);
    // Rule at src/isa/x64/inst.isle line 4677.
    return v2.clone();
}
// Generated as internal constructor for term elf_tls_get_addr.
pub fn constructor_elf_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::ElfTlsGetAddr {
        symbol: arg0,
        dst: v1,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4725.
    return v4;
}
// Generated as internal constructor for term macho_tls_get_addr.
pub fn constructor_macho_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::MachOTlsGetAddr {
        symbol: arg0,
        dst: v1,
    };
    let v3 = C::emit(ctx, &v2);
    let v4 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4732.
    return v4;
}
// Generated as internal constructor for term coff_tls_get_addr.
pub fn constructor_coff_tls_get_addr<C: Context>(ctx: &mut C, arg0: ExternalName) -> Gpr {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = C::temp_writable_gpr(ctx);
    let v3 = MInst::CoffTlsGetAddr {
        symbol: arg0,
        dst: v1,
        tmp: v2,
    };
    let v4 = C::emit(ctx, &v3);
    let v5 = C::writable_gpr_to_gpr(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4739.
    return v5;
}
// Generated as internal constructor for term reg_to_xmm_mem.
pub fn constructor_reg_to_xmm_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {
    let v1 = C::xmm_new(ctx, arg0);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4837.
    return v2.clone();
}
// Generated as internal constructor for term xmm_to_reg_mem.
pub fn constructor_xmm_to_reg_mem<C: Context>(ctx: &mut C, arg0: Reg) -> XmmMem {
    let v1 = C::xmm_new(ctx, arg0);
    let v2 = C::xmm_to_reg(ctx, v1);
    let v3 = RegMem::Reg { reg: v2 };
    let v4 = &C::reg_mem_to_xmm_mem(ctx, &v3);
    // Rule at src/isa/x64/inst.isle line 4840.
    return v4.clone();
}
// Generated as internal constructor for term writable_gpr_to_r_reg.
pub fn constructor_writable_gpr_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableGpr) -> Reg {
    let v1 = C::writable_gpr_to_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4844.
    return v2;
}
// Generated as internal constructor for term writable_gpr_to_gpr_mem.
pub fn constructor_writable_gpr_to_gpr_mem<C: Context>(ctx: &mut C, arg0: WritableGpr) -> GprMem {
    let v1 = C::writable_gpr_to_gpr(ctx, arg0);
    let v2 = &C::gpr_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4847.
    return v2.clone();
}
// Generated as internal constructor for term writable_gpr_to_value_regs.
pub fn constructor_writable_gpr_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableGpr,
) -> ValueRegs {
    let v1 = constructor_writable_gpr_to_r_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4850.
    return v2;
}
// Generated as internal constructor for term writable_xmm_to_r_reg.
pub fn constructor_writable_xmm_to_r_reg<C: Context>(ctx: &mut C, arg0: WritableXmm) -> Reg {
    let v1 = C::writable_xmm_to_reg(ctx, arg0);
    let v2 = C::writable_reg_to_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4853.
    return v2;
}
// Generated as internal constructor for term writable_xmm_to_xmm_mem.
pub fn constructor_writable_xmm_to_xmm_mem<C: Context>(ctx: &mut C, arg0: WritableXmm) -> XmmMem {
    let v1 = C::writable_xmm_to_xmm(ctx, arg0);
    let v2 = &C::xmm_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4856.
    return v2.clone();
}
// Generated as internal constructor for term writable_xmm_to_value_regs.
pub fn constructor_writable_xmm_to_value_regs<C: Context>(
    ctx: &mut C,
    arg0: WritableXmm,
) -> ValueRegs {
    let v1 = constructor_writable_xmm_to_r_reg(ctx, arg0);
    let v2 = C::value_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4859.
    return v2;
}
// Generated as internal constructor for term synthetic_amode_to_gpr_mem.
pub fn constructor_synthetic_amode_to_gpr_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> GprMem {
    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4866.
    return v2.clone();
}
// Generated as internal constructor for term amode_to_gpr_mem.
pub fn constructor_amode_to_gpr_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> GprMem {
    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_gpr_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4864.
    return v2.clone();
}
// Generated as internal constructor for term amode_to_xmm_mem.
pub fn constructor_amode_to_xmm_mem<C: Context>(ctx: &mut C, arg0: &Amode) -> XmmMem {
    let v1 = &C::amode_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4869.
    return v2.clone();
}
// Generated as internal constructor for term synthetic_amode_to_xmm_mem.
pub fn constructor_synthetic_amode_to_xmm_mem<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> XmmMem {
    let v1 = &C::synthetic_amode_to_reg_mem(ctx, arg0);
    let v2 = &C::reg_mem_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4872.
    return v2.clone();
}
// Generated as internal constructor for term const_to_xmm_mem.
pub fn constructor_const_to_xmm_mem<C: Context>(ctx: &mut C, arg0: VCodeConstant) -> XmmMem {
    let v1 = &C::const_to_synthetic_amode(ctx, arg0);
    let v2 = &constructor_synthetic_amode_to_xmm_mem(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4877.
    return v2.clone();
}
// Generated as internal constructor for term xmm_to_xmm_mem_aligned.
pub fn constructor_xmm_to_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Xmm) -> XmmMemAligned {
    let v1 = &C::xmm_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4880.
    return v2.clone();
}
// Generated as internal constructor for term amode_to_xmm_mem_aligned.
pub fn constructor_amode_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: &Amode,
) -> XmmMemAligned {
    let v1 = &constructor_amode_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4882.
    return v2.clone();
}
// Generated as internal constructor for term synthetic_amode_to_xmm_mem_aligned.
pub fn constructor_synthetic_amode_to_xmm_mem_aligned<C: Context>(
    ctx: &mut C,
    arg0: &SyntheticAmode,
) -> XmmMemAligned {
    let v1 = &constructor_synthetic_amode_to_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4884.
    return v2.clone();
}
// Generated as internal constructor for term put_in_xmm_mem_aligned.
pub fn constructor_put_in_xmm_mem_aligned<C: Context>(ctx: &mut C, arg0: Value) -> XmmMemAligned {
    let v1 = &C::put_in_xmm_mem(ctx, arg0);
    let v2 = &C::xmm_mem_to_xmm_mem_aligned(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4886.
    return v2.clone();
}
// Generated as internal constructor for term mov_from_preg.
pub fn constructor_mov_from_preg<C: Context>(ctx: &mut C, arg0: PReg) -> Reg {
    let v1 = C::temp_writable_gpr(ctx);
    let v2 = MInst::MovFromPReg { src: arg0, dst: v1 };
    let v3 = C::emit(ctx, &v2);
    let v4 = constructor_writable_gpr_to_r_reg(ctx, v1);
    // Rule at src/isa/x64/inst.isle line 4890.
    return v4;
}
// Generated as internal constructor for term mov_to_preg.
pub fn constructor_mov_to_preg<C: Context>(
    ctx: &mut C,
    arg0: PReg,
    arg1: Gpr,
) -> SideEffectNoResult {
    let v2 = MInst::MovToPReg {
        src: arg1,
        dst: arg0,
    };
    let v3 = SideEffectNoResult::Inst { inst: v2 };
    // Rule at src/isa/x64/inst.isle line 4896.
    return v3;
}
// Generated as internal constructor for term x64_rbp.
pub fn constructor_x64_rbp<C: Context>(ctx: &mut C) -> Reg {
    let v0 = C::preg_rbp(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 4909.
    return v1;
}
// Generated as internal constructor for term x64_rsp.
pub fn constructor_x64_rsp<C: Context>(ctx: &mut C) -> Reg {
    let v0 = C::preg_rsp(ctx);
    let v1 = constructor_mov_from_preg(ctx, v0);
    // Rule at src/isa/x64/inst.isle line 4913.
    return v1;
}
// Generated as internal constructor for term lower.
pub fn constructor_lower<C: Context>(ctx: &mut C, arg0: Inst) -> Option<InstOutput> {
    let v6 = &C::inst_data(ctx, arg0);
    match v6 {
        &InstructionData::AtomicCas {
            opcode: ref v1488,
            args: ref v1489,
            flags: v1490,
        } => {
            if let &Opcode::AtomicCas = v1488 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v1463 = C::ty_int(ctx, v3);
                        if let Some(v1464) = v1463 {
                            let v1491 = C::unpack_value_array_3(ctx, v1489);
                            let v1495 = constructor_put_in_gpr(ctx, v1491.1);
                            let v1496 = constructor_put_in_gpr(ctx, v1491.2);
                            let v1497 = C::zero_offset(ctx);
                            let v1498 = &constructor_to_amode(ctx, v1490, v1491.0, v1497);
                            let v1499 = &C::amode_to_synthetic_amode(ctx, v1498);
                            let v1500 = constructor_x64_cmpxchg(ctx, v5, v1495, v1496, v1499);
                            let v1501 = constructor_output_gpr(ctx, v1500);
                            // Rule at src/isa/x64/lower.isle line 2749.
                            return Some(v1501);
                        }
                    }
                }
            }
        }
        &InstructionData::AtomicRmw {
            opcode: ref v1502,
            args: ref v1503,
            flags: v1504,
            op: ref v1505,
        } => {
            if let &Opcode::AtomicRmw = v1502 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v1463 = C::ty_int(ctx, v3);
                        if let Some(v1464) = v1463 {
                            let v1509 = &C::atomic_rmw_op_to_mach_atomic_rmw_op(ctx, v1505);
                            let v1465 = C::zero_offset(ctx);
                            let v1506 = C::unpack_value_array_2(ctx, v1503);
                            let v1510 = &constructor_to_amode(ctx, v1504, v1506.0, v1465);
                            let v1511 = &C::amode_to_synthetic_amode(ctx, v1510);
                            let v1512 = constructor_put_in_gpr(ctx, v1506.1);
                            let v1513 =
                                constructor_x64_atomic_rmw_seq(ctx, v5, v1509, v1511, v1512);
                            let v1514 = constructor_output_gpr(ctx, v1513);
                            // Rule at src/isa/x64/lower.isle line 2765.
                            return Some(v1514);
                        }
                    }
                }
            }
        }
        &InstructionData::Binary {
            opcode: ref v36,
            args: ref v37,
        } => {
            match v36 {
                &Opcode::Swizzle => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                    let v2072 = C::swizzle_zero_mask(ctx);
                    let v2073 = &constructor_const_to_xmm_mem(ctx, v2072);
                    let v2074 = constructor_x64_paddusb(ctx, v1013, v2073);
                    let v2075 = constructor_put_in_xmm(ctx, v38.0);
                    let v2076 = &C::xmm_to_xmm_mem(ctx, v2074);
                    let v2077 = constructor_x64_pshufb(ctx, v2075, v2076);
                    let v2078 = constructor_output_xmm(ctx, v2077);
                    // Rule at src/isa/x64/lower.isle line 3702.
                    return Some(v2078);
                }
                &Opcode::X86Pshufb => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v68 = constructor_put_in_xmm(ctx, v38.0);
                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                    let v2079 = constructor_x64_pshufb(ctx, v68, v69);
                    let v2080 = constructor_output_xmm(ctx, v2079);
                    // Rule at src/isa/x64/lower.isle line 3708.
                    return Some(v2080);
                }
                &Opcode::Smin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v600 = constructor_x64_pminsb(ctx, v68, v69);
                                let v601 = constructor_output_xmm(ctx, v600);
                                // Rule at src/isa/x64/lower.isle line 1332.
                                return Some(v601);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v602 = constructor_x64_pminsw(ctx, v68, v69);
                                let v603 = constructor_output_xmm(ctx, v602);
                                // Rule at src/isa/x64/lower.isle line 1335.
                                return Some(v603);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v604 = constructor_x64_pminsd(ctx, v68, v69);
                                let v605 = constructor_output_xmm(ctx, v604);
                                // Rule at src/isa/x64/lower.isle line 1338.
                                return Some(v605);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v589 = constructor_cmp_and_choose(ctx, v5, &CC::L, v38.0, v38.1);
                            let v590 = C::output(ctx, v589);
                            // Rule at src/isa/x64/lower.isle line 1313.
                            return Some(v590);
                        }
                    }
                }
                &Opcode::Umin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v612 = constructor_x64_pminub(ctx, v68, v69);
                                let v613 = constructor_output_xmm(ctx, v612);
                                // Rule at src/isa/x64/lower.isle line 1354.
                                return Some(v613);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v614 = constructor_x64_pminuw(ctx, v68, v69);
                                let v615 = constructor_output_xmm(ctx, v614);
                                // Rule at src/isa/x64/lower.isle line 1357.
                                return Some(v615);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v616 = constructor_x64_pminud(ctx, v68, v69);
                                let v617 = constructor_output_xmm(ctx, v616);
                                // Rule at src/isa/x64/lower.isle line 1360.
                                return Some(v617);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v583 = constructor_cmp_and_choose(ctx, v5, &CC::B, v38.0, v38.1);
                            let v584 = C::output(ctx, v583);
                            // Rule at src/isa/x64/lower.isle line 1307.
                            return Some(v584);
                        }
                    }
                }
                &Opcode::Smax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v594 = constructor_x64_pmaxsb(ctx, v68, v69);
                                let v595 = constructor_output_xmm(ctx, v594);
                                // Rule at src/isa/x64/lower.isle line 1321.
                                return Some(v595);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v596 = constructor_x64_pmaxsw(ctx, v68, v69);
                                let v597 = constructor_output_xmm(ctx, v596);
                                // Rule at src/isa/x64/lower.isle line 1324.
                                return Some(v597);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v598 = constructor_x64_pmaxsd(ctx, v68, v69);
                                let v599 = constructor_output_xmm(ctx, v598);
                                // Rule at src/isa/x64/lower.isle line 1327.
                                return Some(v599);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v592 = constructor_cmp_and_choose(ctx, v5, &CC::NL, v38.0, v38.1);
                            let v593 = C::output(ctx, v592);
                            // Rule at src/isa/x64/lower.isle line 1316.
                            return Some(v593);
                        }
                    }
                }
                &Opcode::Umax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v606 = constructor_x64_pmaxub(ctx, v68, v69);
                                let v607 = constructor_output_xmm(ctx, v606);
                                // Rule at src/isa/x64/lower.isle line 1343.
                                return Some(v607);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v608 = constructor_x64_pmaxuw(ctx, v68, v69);
                                let v609 = constructor_output_xmm(ctx, v608);
                                // Rule at src/isa/x64/lower.isle line 1346.
                                return Some(v609);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v610 = constructor_x64_pmaxud(ctx, v68, v69);
                                let v611 = constructor_output_xmm(ctx, v610);
                                // Rule at src/isa/x64/lower.isle line 1349.
                                return Some(v611);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v586 = constructor_cmp_and_choose(ctx, v5, &CC::NB, v38.0, v38.1);
                            let v587 = C::output(ctx, v586);
                            // Rule at src/isa/x64/lower.isle line 1310.
                            return Some(v587);
                        }
                    }
                }
                &Opcode::AvgRound => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v335 = constructor_x64_pavgb(ctx, v68, v69);
                                        let v336 = constructor_output_xmm(ctx, v335);
                                        // Rule at src/isa/x64/lower.isle line 779.
                                        return Some(v336);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v337 = constructor_x64_pavgw(ctx, v68, v69);
                                        let v338 = constructor_output_xmm(ctx, v337);
                                        // Rule at src/isa/x64/lower.isle line 783.
                                        return Some(v338);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v108 = constructor_x64_paddusb(ctx, v68, v69);
                                        let v109 = constructor_output_xmm(ctx, v108);
                                        // Rule at src/isa/x64/lower.isle line 126.
                                        return Some(v109);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v110 = constructor_x64_paddusw(ctx, v68, v69);
                                        let v111 = constructor_output_xmm(ctx, v110);
                                        // Rule at src/isa/x64/lower.isle line 130.
                                        return Some(v111);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SaddSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v104 = constructor_x64_paddsb(ctx, v68, v69);
                                        let v105 = constructor_output_xmm(ctx, v104);
                                        // Rule at src/isa/x64/lower.isle line 116.
                                        return Some(v105);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v106 = constructor_x64_paddsw(ctx, v68, v69);
                                        let v107 = constructor_output_xmm(ctx, v106);
                                        // Rule at src/isa/x64/lower.isle line 120.
                                        return Some(v107);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::UsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v130 = constructor_x64_psubusb(ctx, v68, v69);
                                        let v131 = constructor_output_xmm(ctx, v130);
                                        // Rule at src/isa/x64/lower.isle line 187.
                                        return Some(v131);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v132 = constructor_x64_psubusw(ctx, v68, v69);
                                        let v133 = constructor_output_xmm(ctx, v132);
                                        // Rule at src/isa/x64/lower.isle line 191.
                                        return Some(v133);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::SsubSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v126 = constructor_x64_psubsb(ctx, v68, v69);
                                        let v127 = constructor_output_xmm(ctx, v126);
                                        // Rule at src/isa/x64/lower.isle line 177.
                                        return Some(v127);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v128 = constructor_x64_psubsw(ctx, v68, v69);
                                        let v129 = constructor_output_xmm(ctx, v128);
                                        // Rule at src/isa/x64/lower.isle line 181.
                                        return Some(v129);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }
                &Opcode::Iadd => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);
                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);
                            let v83 = C::put_in_regs(ctx, v38.1);
                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);
                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);
                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);
                            let v87 = &constructor_x64_add_with_flags_paired(ctx, I64, v80, v86);
                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);
                            let v89 = &constructor_x64_adc_paired(ctx, I64, v82, v88);
                            let v90 = constructor_with_flags(ctx, v87, v89);
                            let v91 = C::output(ctx, v90);
                            // Rule at src/isa/x64/lower.isle line 88.
                            return Some(v91);
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v70 = constructor_x64_paddb(ctx, v68, v69);
                                        let v71 = constructor_output_xmm(ctx, v70);
                                        // Rule at src/isa/x64/lower.isle line 71.
                                        return Some(v71);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v72 = constructor_x64_paddw(ctx, v68, v69);
                                        let v73 = constructor_output_xmm(ctx, v72);
                                        // Rule at src/isa/x64/lower.isle line 75.
                                        return Some(v73);
                                    }
                                }
                                0x20 => {
                                    if v65.1 == 0x4 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v74 = constructor_x64_paddd(ctx, v68, v69);
                                        let v75 = constructor_output_xmm(ctx, v74);
                                        // Rule at src/isa/x64/lower.isle line 79.
                                        return Some(v75);
                                    }
                                }
                                0x40 => {
                                    if v65.1 == 0x2 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v76 = constructor_x64_paddq(ctx, v68, v69);
                                        let v77 = constructor_output_xmm(ctx, v76);
                                        // Rule at src/isa/x64/lower.isle line 83.
                                        return Some(v77);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v58 = &C::sinkable_load(ctx, v38.0);
                            if let Some(v59) = v58 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);
                                let v62 = constructor_x64_add(ctx, v5, v60, v61);
                                let v63 = constructor_output_gpr(ctx, v62);
                                // Rule at src/isa/x64/lower.isle line 65.
                                return Some(v63);
                            }
                            let v53 = &C::sinkable_load(ctx, v38.1);
                            if let Some(v54) = v53 {
                                let v41 = constructor_put_in_gpr(ctx, v38.0);
                                let v55 = &constructor_sink_load_to_gpr_mem_imm(ctx, v54);
                                let v56 = constructor_x64_add(ctx, v5, v41, v55);
                                let v57 = constructor_output_gpr(ctx, v56);
                                // Rule at src/isa/x64/lower.isle line 62.
                                return Some(v57);
                            }
                        }
                        let v45 = C::ty_32_or_64(ctx, v3);
                        if let Some(v46) = v45 {
                            let v48 = C::zero_offset(ctx);
                            let v47 = C::mem_flags_trusted(ctx);
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v49 = &constructor_to_amode_add(ctx, v47, v38.0, v38.1, v48);
                            let v50 = &C::amode_to_synthetic_amode(ctx, v49);
                            let v51 = constructor_x64_lea(ctx, v46, v50);
                            let v52 = constructor_output_gpr(ctx, v51);
                            // Rule at src/isa/x64/lower.isle line 56.
                            return Some(v52);
                        }
                        let v34 = C::fits_in_16(ctx, v3);
                        if let Some(v35) = v34 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v43 = constructor_x64_add(ctx, v35, v41, v42);
                            let v44 = constructor_output_gpr(ctx, v43);
                            // Rule at src/isa/x64/lower.isle line 45.
                            return Some(v44);
                        }
                    }
                }
                &Opcode::Isub => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);
                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);
                            let v83 = C::put_in_regs(ctx, v38.1);
                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);
                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);
                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);
                            let v122 = &constructor_x64_sub_with_flags_paired(ctx, I64, v80, v86);
                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);
                            let v123 = &constructor_x64_sbb_paired(ctx, I64, v82, v88);
                            let v124 = constructor_with_flags(ctx, v122, v123);
                            let v125 = C::output(ctx, v124);
                            // Rule at src/isa/x64/lower.isle line 162.
                            return Some(v125);
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x8 => {
                                    if v65.1 == 0x10 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v114 = constructor_x64_psubb(ctx, v68, v69);
                                        let v115 = constructor_output_xmm(ctx, v114);
                                        // Rule at src/isa/x64/lower.isle line 145.
                                        return Some(v115);
                                    }
                                }
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v116 = constructor_x64_psubw(ctx, v68, v69);
                                        let v117 = constructor_output_xmm(ctx, v116);
                                        // Rule at src/isa/x64/lower.isle line 149.
                                        return Some(v117);
                                    }
                                }
                                0x20 => {
                                    if v65.1 == 0x4 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v118 = constructor_x64_psubd(ctx, v68, v69);
                                        let v119 = constructor_output_xmm(ctx, v118);
                                        // Rule at src/isa/x64/lower.isle line 153.
                                        return Some(v119);
                                    }
                                }
                                0x40 => {
                                    if v65.1 == 0x2 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v120 = constructor_x64_psubq(ctx, v68, v69);
                                        let v121 = constructor_output_xmm(ctx, v120);
                                        // Rule at src/isa/x64/lower.isle line 157.
                                        return Some(v121);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v112 = constructor_x64_sub(ctx, v5, v41, v42);
                            let v113 = constructor_output_gpr(ctx, v112);
                            // Rule at src/isa/x64/lower.isle line 139.
                            return Some(v113);
                        }
                    }
                }
                &Opcode::Imul => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            if v65.0 == 0x40 {
                                if v65.1 == 0x2 {
                                    let v363 = C::avx512vl_enabled(ctx, v3);
                                    if v363 == true {
                                        let v364 = C::avx512dq_enabled(ctx, v3);
                                        if v364 == true {
                                            let v38 = C::unpack_value_array_2(ctx, v37);
                                            let v365 = &C::put_in_xmm_mem(ctx, v38.0);
                                            let v366 = constructor_put_in_xmm(ctx, v38.1);
                                            let v367 = constructor_x64_vpmullq(ctx, v365, v366);
                                            let v368 = constructor_output_xmm(ctx, v367);
                                            // Rule at src/isa/x64/lower.isle line 855.
                                            return Some(v368);
                                        }
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);
                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);
                            let v83 = C::put_in_regs(ctx, v38.1);
                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);
                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);
                            let v345 = &C::gpr_to_gpr_mem_imm(ctx, v85);
                            let v346 = constructor_x64_mul(ctx, I64, v80, v345);
                            let v347 = &C::gpr_to_gpr_mem_imm(ctx, v84);
                            let v348 = constructor_x64_mul(ctx, I64, v82, v347);
                            let v349 = &C::gpr_to_gpr_mem_imm(ctx, v348);
                            let v350 = constructor_x64_add(ctx, I64, v346, v349);
                            let v351 = &C::gpr_to_gpr_mem(ctx, v84);
                            let v352 = constructor_mulhi_u(ctx, I64, v80, v351);
                            let v353 = constructor_value_regs_get_gpr(ctx, v352, 0x0);
                            let v354 = constructor_value_regs_get_gpr(ctx, v352, 0x1);
                            let v355 = &C::gpr_to_gpr_mem_imm(ctx, v354);
                            let v356 = constructor_x64_add(ctx, I64, v350, v355);
                            let v357 = constructor_value_gprs(ctx, v353, v356);
                            let v358 = C::output(ctx, v357);
                            // Rule at src/isa/x64/lower.isle line 820.
                            return Some(v358);
                        }
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x10 => {
                                    if v65.1 == 0x8 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v154 = C::def_inst(ctx, v38.1);
                                        if let Some(v155) = v154 {
                                            let v156 = &C::inst_data(ctx, v155);
                                            if let &InstructionData::Unary {
                                                opcode: ref v157,
                                                arg: v158,
                                            } = v156
                                            {
                                                match v157 {
                                                    &Opcode::SwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x8 {
                                                                            if v389.1 == 0x10 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0 == 0x8
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x10
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v426 = constructor_x64_pmovsxbw(ctx, v418);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v427 = constructor_x64_pmovsxbw(ctx, v421);
                                                                                            let v428 = &C::xmm_to_xmm_mem(ctx, v427);
                                                                                            let v429 = constructor_x64_pmullw(ctx, v426, v428);
                                                                                            let v430 = constructor_output_xmm(ctx, v429);
                                                                                            // Rule at src/isa/x64/lower.isle line 939.
                                                                                            return Some(v430);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x8 {
                                                                            if v389.1 == 0x10 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0 == 0x8
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x10
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v397 = &C::xmm_to_xmm_mem(ctx, v168);
                                                                                            let v399 = constructor_x64_palignr(ctx, v168, v397, 0x8);
                                                                                            let v400 = &C::xmm_to_xmm_mem(ctx, v399);
                                                                                            let v401 = constructor_x64_pmovsxbw(ctx, v400);
                                                                                            let v402 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v403 = &C::xmm_to_xmm_mem(ctx, v402);
                                                                                            let v404 = constructor_x64_palignr(ctx, v402, v403, 0x8);
                                                                                            let v405 = &C::xmm_to_xmm_mem(ctx, v404);
                                                                                            let v406 = constructor_x64_pmovsxbw(ctx, v405);
                                                                                            let v407 = &C::xmm_to_xmm_mem(ctx, v406);
                                                                                            let v408 = constructor_x64_pmullw(ctx, v401, v407);
                                                                                            let v409 = constructor_output_xmm(ctx, v408);
                                                                                            // Rule at src/isa/x64/lower.isle line 903.
                                                                                            return Some(v409);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x8 {
                                                                            if v389.1 == 0x10 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0 == 0x8
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x10
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v450 = constructor_x64_pmovzxbw(ctx, v418);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v451 = constructor_x64_pmovzxbw(ctx, v421);
                                                                                            let v452 = &C::xmm_to_xmm_mem(ctx, v451);
                                                                                            let v453 = constructor_x64_pmullw(ctx, v450, v452);
                                                                                            let v454 = constructor_output_xmm(ctx, v453);
                                                                                            // Rule at src/isa/x64/lower.isle line 1007.
                                                                                            return Some(v454);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x8 {
                                                                            if v389.1 == 0x10 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0 == 0x8
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x10
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v397 = &C::xmm_to_xmm_mem(ctx, v168);
                                                                                            let v399 = constructor_x64_palignr(ctx, v168, v397, 0x8);
                                                                                            let v400 = &C::xmm_to_xmm_mem(ctx, v399);
                                                                                            let v439 = constructor_x64_pmovzxbw(ctx, v400);
                                                                                            let v402 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v403 = &C::xmm_to_xmm_mem(ctx, v402);
                                                                                            let v404 = constructor_x64_palignr(ctx, v402, v403, 0x8);
                                                                                            let v405 = &C::xmm_to_xmm_mem(ctx, v404);
                                                                                            let v440 = constructor_x64_pmovzxbw(ctx, v405);
                                                                                            let v441 = &C::xmm_to_xmm_mem(ctx, v440);
                                                                                            let v442 = constructor_x64_pmullw(ctx, v439, v441);
                                                                                            let v443 = constructor_output_xmm(ctx, v442);
                                                                                            // Rule at src/isa/x64/lower.isle line 971.
                                                                                            return Some(v443);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v359 = constructor_x64_pmullw(ctx, v68, v69);
                                        let v360 = constructor_output_xmm(ctx, v359);
                                        // Rule at src/isa/x64/lower.isle line 847.
                                        return Some(v360);
                                    }
                                }
                                0x20 => {
                                    if v65.1 == 0x4 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v154 = C::def_inst(ctx, v38.1);
                                        if let Some(v155) = v154 {
                                            let v156 = &C::inst_data(ctx, v155);
                                            if let &InstructionData::Unary {
                                                opcode: ref v157,
                                                arg: v158,
                                            } = v156
                                            {
                                                match v157 {
                                                    &Opcode::SwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x10 {
                                                                            if v389.1 == 0x8 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x10
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x8
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);
                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v414 = constructor_x64_pmulhw(ctx, v168, v413);
                                                                                            let v415 = &C::xmm_to_xmm_mem(ctx, v414);
                                                                                            let v431 = constructor_x64_punpcklwd(ctx, v412, v415);
                                                                                            let v432 = constructor_output_xmm(ctx, v431);
                                                                                            // Rule at src/isa/x64/lower.isle line 949.
                                                                                            return Some(v432);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x10 {
                                                                            if v389.1 == 0x8 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x10
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x8
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);
                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v414 = constructor_x64_pmulhw(ctx, v168, v413);
                                                                                            let v415 = &C::xmm_to_xmm_mem(ctx, v414);
                                                                                            let v416 = constructor_x64_punpckhwd(ctx, v412, v415);
                                                                                            let v417 = constructor_output_xmm(ctx, v416);
                                                                                            // Rule at src/isa/x64/lower.isle line 917.
                                                                                            return Some(v417);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x10 {
                                                                            if v389.1 == 0x8 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x10
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x8
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);
                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v444 = constructor_x64_pmulhuw(ctx, v168, v413);
                                                                                            let v445 = &C::xmm_to_xmm_mem(ctx, v444);
                                                                                            let v455 = constructor_x64_punpcklwd(ctx, v412, v445);
                                                                                            let v456 = constructor_output_xmm(ctx, v455);
                                                                                            // Rule at src/isa/x64/lower.isle line 1017.
                                                                                            return Some(v456);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x10 {
                                                                            if v389.1 == 0x8 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x10
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x8
                                                                                        {
                                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                                            let v410 = constructor_put_in_xmm(ctx, v158);
                                                                                            let v411 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v412 = constructor_x64_pmullw(ctx, v168, v411);
                                                                                            let v413 = &C::xmm_to_xmm_mem(ctx, v410);
                                                                                            let v444 = constructor_x64_pmulhuw(ctx, v168, v413);
                                                                                            let v445 = &C::xmm_to_xmm_mem(ctx, v444);
                                                                                            let v446 = constructor_x64_punpckhwd(ctx, v412, v445);
                                                                                            let v447 = constructor_output_xmm(ctx, v446);
                                                                                            // Rule at src/isa/x64/lower.isle line 985.
                                                                                            return Some(v447);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v361 = constructor_x64_pmulld(ctx, v68, v69);
                                        let v362 = constructor_output_xmm(ctx, v361);
                                        // Rule at src/isa/x64/lower.isle line 850.
                                        return Some(v362);
                                    }
                                }
                                0x40 => {
                                    if v65.1 == 0x2 {
                                        let v38 = C::unpack_value_array_2(ctx, v37);
                                        let v154 = C::def_inst(ctx, v38.1);
                                        if let Some(v155) = v154 {
                                            let v156 = &C::inst_data(ctx, v155);
                                            if let &InstructionData::Unary {
                                                opcode: ref v157,
                                                arg: v158,
                                            } = v156
                                            {
                                                match v157 {
                                                    &Opcode::SwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x20 {
                                                                            if v389.1 == 0x4 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x20
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x4
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v434 = constructor_x64_pshufd(ctx, v418, 0x50);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v435 = constructor_x64_pshufd(ctx, v421, 0x50);
                                                                                            let v436 = &C::xmm_to_xmm_mem(ctx, v435);
                                                                                            let v437 = constructor_x64_pmuldq(ctx, v434, v436);
                                                                                            let v438 = constructor_output_xmm(ctx, v437);
                                                                                            // Rule at src/isa/x64/lower.isle line 961.
                                                                                            return Some(v438);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::SwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::SwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x20 {
                                                                            if v389.1 == 0x4 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x20
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x4
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v420 = constructor_x64_pshufd(ctx, v418, 0xFA);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v422 = constructor_x64_pshufd(ctx, v421, 0xFA);
                                                                                            let v423 = &C::xmm_to_xmm_mem(ctx, v422);
                                                                                            let v424 = constructor_x64_pmuldq(ctx, v420, v423);
                                                                                            let v425 = constructor_output_xmm(ctx, v424);
                                                                                            // Rule at src/isa/x64/lower.isle line 929.
                                                                                            return Some(v425);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenLow => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenLow = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x20 {
                                                                            if v389.1 == 0x4 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x20
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x4
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v434 = constructor_x64_pshufd(ctx, v418, 0x50);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v435 = constructor_x64_pshufd(ctx, v421, 0x50);
                                                                                            let v436 = &C::xmm_to_xmm_mem(ctx, v435);
                                                                                            let v457 = constructor_x64_pmuludq(ctx, v434, v436);
                                                                                            let v458 = constructor_output_xmm(ctx, v457);
                                                                                            // Rule at src/isa/x64/lower.isle line 1029.
                                                                                            return Some(v458);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    &Opcode::UwidenHigh => {
                                                        let v163 = C::def_inst(ctx, v38.0);
                                                        if let Some(v164) = v163 {
                                                            let v165 = &C::inst_data(ctx, v164);
                                                            if let &InstructionData::Unary {
                                                                opcode: ref v166,
                                                                arg: v167,
                                                            } = v165
                                                            {
                                                                if let &Opcode::UwidenHigh = v166 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    let v388 =
                                                                        C::multi_lane(ctx, v387);
                                                                    if let Some(v389) = v388 {
                                                                        if v389.0 == 0x20 {
                                                                            if v389.1 == 0x4 {
                                                                                let v392 =
                                                                                    C::value_type(
                                                                                        ctx, v158,
                                                                                    );
                                                                                let v393 =
                                                                                    C::multi_lane(
                                                                                        ctx, v392,
                                                                                    );
                                                                                if let Some(v394) =
                                                                                    v393
                                                                                {
                                                                                    if v394.0
                                                                                        == 0x20
                                                                                    {
                                                                                        if v394.1
                                                                                            == 0x4
                                                                                        {
                                                                                            let v418 = &C::put_in_xmm_mem(ctx, v167);
                                                                                            let v420 = constructor_x64_pshufd(ctx, v418, 0xFA);
                                                                                            let v421 = &C::put_in_xmm_mem(ctx, v158);
                                                                                            let v422 = constructor_x64_pshufd(ctx, v421, 0xFA);
                                                                                            let v423 = &C::xmm_to_xmm_mem(ctx, v422);
                                                                                            let v448 = constructor_x64_pmuludq(ctx, v420, v423);
                                                                                            let v449 = constructor_output_xmm(ctx, v448);
                                                                                            // Rule at src/isa/x64/lower.isle line 997.
                                                                                            return Some(v449);
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                                        let v366 = constructor_put_in_xmm(ctx, v38.1);
                                        let v370 = &C::xmi_imm(ctx, 0x20);
                                        let v371 = constructor_x64_psrlq(ctx, v68, v370);
                                        let v372 = &C::xmm_to_xmm_mem(ctx, v366);
                                        let v373 = constructor_x64_pmuludq(ctx, v371, v372);
                                        let v374 = &C::xmi_imm(ctx, 0x20);
                                        let v375 = constructor_x64_psrlq(ctx, v366, v374);
                                        let v376 = &C::xmm_to_xmm_mem(ctx, v375);
                                        let v377 = constructor_x64_pmuludq(ctx, v68, v376);
                                        let v378 = &C::xmm_to_xmm_mem(ctx, v377);
                                        let v379 = constructor_x64_paddq(ctx, v373, v378);
                                        let v380 = &C::xmi_imm(ctx, 0x20);
                                        let v381 = constructor_x64_psllq(ctx, v379, v380);
                                        let v382 = &C::xmm_to_xmm_mem(ctx, v366);
                                        let v383 = constructor_x64_pmuludq(ctx, v68, v382);
                                        let v384 = &C::xmm_to_xmm_mem(ctx, v381);
                                        let v385 = constructor_x64_paddq(ctx, v383, v384);
                                        let v386 = constructor_output_xmm(ctx, v385);
                                        // Rule at src/isa/x64/lower.isle line 881.
                                        return Some(v386);
                                    }
                                }
                                _ => {}
                            }
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v58 = &C::sinkable_load(ctx, v38.0);
                            if let Some(v59) = v58 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);
                                let v343 = constructor_x64_mul(ctx, v5, v60, v61);
                                let v344 = constructor_output_gpr(ctx, v343);
                                // Rule at src/isa/x64/lower.isle line 801.
                                return Some(v344);
                            }
                            let v140 = &C::simm32_from_value(ctx, v38.0);
                            if let Some(v141) = v140 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v341 = constructor_x64_mul(ctx, v5, v60, v141);
                                let v342 = constructor_output_gpr(ctx, v341);
                                // Rule at src/isa/x64/lower.isle line 798.
                                return Some(v342);
                            }
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v339 = constructor_x64_mul(ctx, v5, v41, v42);
                            let v340 = constructor_output_gpr(ctx, v339);
                            // Rule at src/isa/x64/lower.isle line 792.
                            return Some(v340);
                        }
                    }
                }
                &Opcode::Umulhi => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    match v1756 {
                        I16 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1940 = constructor_mul_hi(ctx, I16, false, v41, v1939);
                            let v1941 = constructor_value_regs_get_gpr(ctx, v1940, 0x1);
                            let v1942 = constructor_output_gpr(ctx, v1941);
                            // Rule at src/isa/x64/lower.isle line 3504.
                            return Some(v1942);
                        }
                        I32 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1943 = constructor_mul_hi(ctx, I32, false, v41, v1939);
                            let v1944 = constructor_value_regs_get_gpr(ctx, v1943, 0x1);
                            let v1945 = constructor_output_gpr(ctx, v1944);
                            // Rule at src/isa/x64/lower.isle line 3509.
                            return Some(v1945);
                        }
                        I64 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1946 = constructor_mul_hi(ctx, I64, false, v41, v1939);
                            let v1947 = constructor_value_regs_get_gpr(ctx, v1946, 0x1);
                            let v1948 = constructor_output_gpr(ctx, v1947);
                            // Rule at src/isa/x64/lower.isle line 3514.
                            return Some(v1948);
                        }
                        _ => {}
                    }
                }
                &Opcode::Smulhi => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    match v1756 {
                        I16 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1949 = constructor_mul_hi(ctx, I16, true, v41, v1939);
                            let v1950 = constructor_value_regs_get_gpr(ctx, v1949, 0x1);
                            let v1951 = constructor_output_gpr(ctx, v1950);
                            // Rule at src/isa/x64/lower.isle line 3521.
                            return Some(v1951);
                        }
                        I32 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1952 = constructor_mul_hi(ctx, I32, true, v41, v1939);
                            let v1953 = constructor_value_regs_get_gpr(ctx, v1952, 0x1);
                            let v1954 = constructor_output_gpr(ctx, v1953);
                            // Rule at src/isa/x64/lower.isle line 3526.
                            return Some(v1954);
                        }
                        I64 => {
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v1939 = &constructor_put_in_gpr_mem(ctx, v38.1);
                            let v1955 = constructor_mul_hi(ctx, I64, true, v41, v1939);
                            let v1956 = constructor_value_regs_get_gpr(ctx, v1955, 0x1);
                            let v1957 = constructor_output_gpr(ctx, v1956);
                            // Rule at src/isa/x64/lower.isle line 3531.
                            return Some(v1957);
                        }
                        _ => {}
                    }
                }
                &Opcode::SqmulRoundSat => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I16X8 {
                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                        let v366 = constructor_put_in_xmm(ctx, v38.1);
                        let v2223 = C::sqmul_round_sat_mask(ctx);
                        let v2224 = &constructor_const_to_xmm_mem(ctx, v2223);
                        let v372 = &C::xmm_to_xmm_mem(ctx, v366);
                        let v2225 = constructor_x64_pmulhrsw(ctx, v68, v372);
                        let v2226 = constructor_x64_pcmpeqw(ctx, v2225, v2224);
                        let v2227 = &C::xmm_to_xmm_mem(ctx, v2226);
                        let v2228 = constructor_x64_pxor(ctx, v2225, v2227);
                        let v2229 = constructor_output_xmm(ctx, v2228);
                        // Rule at src/isa/x64/lower.isle line 3929.
                        return Some(v2229);
                    }
                }
                &Opcode::X86Pmulhrsw => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I16X8 {
                        let v68 = constructor_put_in_xmm(ctx, v38.0);
                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                        let v2230 = constructor_x64_pmulhrsw(ctx, v68, v69);
                        let v2231 = constructor_output_xmm(ctx, v2230);
                        // Rule at src/isa/x64/lower.isle line 3940.
                        return Some(v2231);
                    }
                }
                &Opcode::Udiv => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I8 {
                        let v1881 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);
                        let v177 = constructor_put_in_gpr(ctx, v38.1);
                        let v1882 = &C::gpr_to_gpr_mem(ctx, v177);
                        let v1885 = constructor_x64_div8(
                            ctx,
                            v1881,
                            v1882,
                            &DivSignedness::Unsigned,
                            &TrapCode::IntegerDivisionByZero,
                        );
                        let v1886 = constructor_output_gpr(ctx, v1885);
                        // Rule at src/isa/x64/lower.isle line 3383.
                        return Some(v1886);
                    }
                    let v1887 = C::fits_in_64(ctx, v1756);
                    if let Some(v1888) = v1887 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v15 = constructor_imm(ctx, I64, 0x0);
                        let v1889 = C::gpr_new(ctx, v15);
                        let v1890 = constructor_put_in_gpr(ctx, v38.1);
                        let v1891 = &C::gpr_to_gpr_mem(ctx, v1890);
                        let v1892 = &C::raw_operand_size_of_type(ctx, v1888);
                        let v1893 = constructor_x64_div_quotient(
                            ctx,
                            v41,
                            v1889,
                            v1891,
                            v1892,
                            &DivSignedness::Unsigned,
                            &TrapCode::IntegerDivisionByZero,
                        );
                        let v1894 = C::output(ctx, v1893);
                        // Rule at src/isa/x64/lower.isle line 3392.
                        return Some(v1894);
                    }
                }
                &Opcode::Sdiv => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I8 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v1896 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);
                        let v1897 = constructor_nonzero_sdiv_divisor(ctx, I8, v38.1);
                        let v1898 = &C::reg_to_gpr_mem(ctx, v1897);
                        let v1901 = constructor_x64_div8(
                            ctx,
                            v1896,
                            v1898,
                            &DivSignedness::Signed,
                            &TrapCode::IntegerOverflow,
                        );
                        let v1902 = constructor_output_gpr(ctx, v1901);
                        // Rule at src/isa/x64/lower.isle line 3402.
                        return Some(v1902);
                    }
                    let v1887 = C::fits_in_64(ctx, v1756);
                    if let Some(v1888) = v1887 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v1903 = &C::raw_operand_size_of_type(ctx, v1888);
                        let v1904 = constructor_x64_sign_extend_data(ctx, v41, v1903);
                        let v1905 = constructor_nonzero_sdiv_divisor(ctx, v1888, v38.1);
                        let v1906 = &C::reg_to_gpr_mem(ctx, v1905);
                        let v1907 = constructor_x64_div_quotient(
                            ctx,
                            v41,
                            v1904,
                            v1906,
                            v1903,
                            &DivSignedness::Signed,
                            &TrapCode::IntegerOverflow,
                        );
                        let v1908 = C::output(ctx, v1907);
                        // Rule at src/isa/x64/lower.isle line 3408.
                        return Some(v1908);
                    }
                }
                &Opcode::Urem => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I8 {
                        let v1881 = constructor_extend_to_gpr(ctx, v38.0, I32, &ExtendKind::Zero);
                        let v177 = constructor_put_in_gpr(ctx, v38.1);
                        let v1882 = &C::gpr_to_gpr_mem(ctx, v177);
                        let v1885 = constructor_x64_div8(
                            ctx,
                            v1881,
                            v1882,
                            &DivSignedness::Unsigned,
                            &TrapCode::IntegerDivisionByZero,
                        );
                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };
                        let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);
                        let v1910 = constructor_x64_shr(ctx, I64, v1885, v1909);
                        let v1911 = constructor_output_gpr(ctx, v1910);
                        // Rule at src/isa/x64/lower.isle line 3441.
                        return Some(v1911);
                    }
                    let v1887 = C::fits_in_64(ctx, v1756);
                    if let Some(v1888) = v1887 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v15 = constructor_imm(ctx, I64, 0x0);
                        let v1889 = C::gpr_new(ctx, v15);
                        let v1890 = constructor_put_in_gpr(ctx, v38.1);
                        let v1891 = &C::gpr_to_gpr_mem(ctx, v1890);
                        let v1892 = &C::raw_operand_size_of_type(ctx, v1888);
                        let v1912 = constructor_x64_div_remainder(
                            ctx,
                            v41,
                            v1889,
                            v1891,
                            v1892,
                            &DivSignedness::Unsigned,
                            &TrapCode::IntegerDivisionByZero,
                        );
                        let v1913 = C::output(ctx, v1912);
                        // Rule at src/isa/x64/lower.isle line 3450.
                        return Some(v1913);
                    }
                }
                &Opcode::Srem => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v154 = C::def_inst(ctx, v38.1);
                    if let Some(v155) = v154 {
                        let v156 = &C::inst_data(ctx, v155);
                        if let &InstructionData::UnaryImm {
                            opcode: ref v1914,
                            imm: v1915,
                        } = v156
                        {
                            if let &Opcode::Iconst = v1914 {
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == I8 {
                                    let v1916 = C::safe_divisor_from_imm64(ctx, I8, v1915);
                                    if let Some(v1917) = v1916 {
                                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                                        let v1896 = constructor_x64_sign_extend_data(
                                            ctx,
                                            v41,
                                            &OperandSize::Size8,
                                        );
                                        let v1918 = constructor_imm(ctx, I8, v1917);
                                        let v1919 = &C::reg_to_gpr_mem(ctx, v1918);
                                        let v1920 = constructor_x64_div8(
                                            ctx,
                                            v1896,
                                            v1919,
                                            &DivSignedness::Signed,
                                            &TrapCode::IntegerDivisionByZero,
                                        );
                                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };
                                        let v1921 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);
                                        let v1922 = constructor_x64_shr(ctx, I64, v1920, v1921);
                                        let v1923 = constructor_output_gpr(ctx, v1922);
                                        // Rule at src/isa/x64/lower.isle line 3465.
                                        return Some(v1923);
                                    }
                                }
                                let v1924 = C::safe_divisor_from_imm64(ctx, v1756, v1915);
                                if let Some(v1925) = v1924 {
                                    let v41 = constructor_put_in_gpr(ctx, v38.0);
                                    let v1926 = &C::raw_operand_size_of_type(ctx, v1756);
                                    let v1927 = constructor_x64_sign_extend_data(ctx, v41, v1926);
                                    let v1928 = constructor_imm(ctx, v1756, v1925);
                                    let v1929 = &C::reg_to_gpr_mem(ctx, v1928);
                                    let v1930 = constructor_x64_div_remainder(
                                        ctx,
                                        v41,
                                        v1927,
                                        v1929,
                                        v1926,
                                        &DivSignedness::Signed,
                                        &TrapCode::IntegerDivisionByZero,
                                    );
                                    let v1931 = C::output(ctx, v1930);
                                    // Rule at src/isa/x64/lower.isle line 3474.
                                    return Some(v1931);
                                }
                            }
                        }
                    }
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I8 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v1896 = constructor_x64_sign_extend_data(ctx, v41, &OperandSize::Size8);
                        let v1932 = constructor_put_in_gpr(ctx, v38.1);
                        let v1933 = constructor_x64_checked_srem_seq8(ctx, v1896, v1932);
                        let v968 = Imm8Reg::Imm8 { imm: 0x8 };
                        let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);
                        let v1934 = constructor_x64_shr(ctx, I64, v1933, v1909);
                        let v1935 = constructor_output_gpr(ctx, v1934);
                        // Rule at src/isa/x64/lower.isle line 3487.
                        return Some(v1935);
                    }
                    let v41 = constructor_put_in_gpr(ctx, v38.0);
                    let v1926 = &C::raw_operand_size_of_type(ctx, v1756);
                    let v1927 = constructor_x64_sign_extend_data(ctx, v41, v1926);
                    let v1890 = constructor_put_in_gpr(ctx, v38.1);
                    let v1936 = constructor_x64_checked_srem_seq(ctx, v1926, v41, v1927, v1890);
                    let v1937 = C::value_regs_get(ctx, v1936, 0x1);
                    let v1938 = constructor_output_reg(ctx, v1937);
                    // Rule at src/isa/x64/lower.isle line 3493.
                    return Some(v1938);
                }
                &Opcode::IaddCout => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v92 = C::value_type(ctx, v38.1);
                    let v93 = C::ty_32_or_64(ctx, v92);
                    if let Some(v94) = v93 {
                        let v41 = constructor_put_in_gpr(ctx, v38.0);
                        let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                        let v95 = &constructor_x64_add_with_flags_paired(ctx, v94, v41, v42);
                        let v97 = &constructor_x64_setcc_paired(ctx, &CC::O);
                        let v98 = constructor_with_flags(ctx, v95, v97);
                        let v99 = C::value_regs_get(ctx, v98, 0x0);
                        let v100 = C::value_reg(ctx, v99);
                        let v101 = C::value_regs_get(ctx, v98, 0x1);
                        let v102 = C::value_reg(ctx, v101);
                        let v103 = C::output_pair(ctx, v100, v102);
                        // Rule at src/isa/x64/lower.isle line 108.
                        return Some(v103);
                    }
                }
                &Opcode::Band => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v135) = v134 {
                            let v171 = C::use_bmi1(ctx, v3);
                            if v171 == true {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v163 = C::def_inst(ctx, v38.0);
                                if let Some(v164) = v163 {
                                    let v165 = &C::inst_data(ctx, v164);
                                    if let &InstructionData::Unary {
                                        opcode: ref v166,
                                        arg: v167,
                                    } = v165
                                    {
                                        if let &Opcode::Bnot = v166 {
                                            let v176 = constructor_put_in_gpr(ctx, v167);
                                            let v177 = constructor_put_in_gpr(ctx, v38.1);
                                            let v178 = constructor_x64_andn(ctx, v3, v176, v177);
                                            let v179 = constructor_output_gpr(ctx, v178);
                                            // Rule at src/isa/x64/lower.isle line 270.
                                            return Some(v179);
                                        }
                                    }
                                }
                                let v154 = C::def_inst(ctx, v38.1);
                                if let Some(v155) = v154 {
                                    let v156 = &C::inst_data(ctx, v155);
                                    if let &InstructionData::Unary {
                                        opcode: ref v157,
                                        arg: v158,
                                    } = v156
                                    {
                                        if let &Opcode::Bnot = v157 {
                                            let v172 = constructor_put_in_gpr(ctx, v158);
                                            let v173 = constructor_put_in_gpr(ctx, v38.0);
                                            let v174 = constructor_x64_andn(ctx, v3, v172, v173);
                                            let v175 = constructor_output_gpr(ctx, v174);
                                            // Rule at src/isa/x64/lower.isle line 266.
                                            return Some(v175);
                                        }
                                    }
                                }
                            }
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v163 = C::def_inst(ctx, v38.0);
                            if let Some(v164) = v163 {
                                let v165 = &C::inst_data(ctx, v164);
                                if let &InstructionData::Unary {
                                    opcode: ref v166,
                                    arg: v167,
                                } = v165
                                {
                                    if let &Opcode::Bnot = v166 {
                                        let v168 = constructor_put_in_xmm(ctx, v167);
                                        let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                        let v169 = constructor_sse_and_not(ctx, v3, v168, v69);
                                        let v170 = constructor_output_xmm(ctx, v169);
                                        // Rule at src/isa/x64/lower.isle line 263.
                                        return Some(v170);
                                    }
                                }
                            }
                            let v154 = C::def_inst(ctx, v38.1);
                            if let Some(v155) = v154 {
                                let v156 = &C::inst_data(ctx, v155);
                                if let &InstructionData::Unary {
                                    opcode: ref v157,
                                    arg: v158,
                                } = v156
                                {
                                    if let &Opcode::Bnot = v157 {
                                        let v159 = constructor_put_in_xmm(ctx, v158);
                                        let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                        let v161 = constructor_sse_and_not(ctx, v3, v159, v160);
                                        let v162 = constructor_output_xmm(ctx, v161);
                                        // Rule at src/isa/x64/lower.isle line 261.
                                        return Some(v162);
                                    }
                                }
                            }
                        }
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);
                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);
                            let v83 = C::put_in_regs(ctx, v38.1);
                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);
                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);
                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);
                            let v150 = constructor_x64_and(ctx, I64, v80, v86);
                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);
                            let v151 = constructor_x64_and(ctx, I64, v82, v88);
                            let v152 = constructor_value_gprs(ctx, v150, v151);
                            let v153 = C::output(ctx, v152);
                            // Rule at src/isa/x64/lower.isle line 235.
                            return Some(v153);
                        }
                        if let Some(v65) = v64 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v148 = constructor_sse_and(ctx, v3, v68, v69);
                            let v149 = constructor_output_xmm(ctx, v148);
                            // Rule at src/isa/x64/lower.isle line 229.
                            return Some(v149);
                        }
                        let v144 = C::ty_scalar_float(ctx, v3);
                        if let Some(v145) = v144 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v146 = constructor_sse_and(ctx, v145, v68, v69);
                            let v147 = constructor_output_xmm(ctx, v146);
                            // Rule at src/isa/x64/lower.isle line 217.
                            return Some(v147);
                        }
                        if let Some(v135) = v134 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v140 = &C::simm32_from_value(ctx, v38.0);
                            if let Some(v141) = v140 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v142 = constructor_x64_and(ctx, v3, v60, v141);
                                let v143 = constructor_output_gpr(ctx, v142);
                                // Rule at src/isa/x64/lower.isle line 211.
                                return Some(v143);
                            }
                            let v58 = &C::sinkable_load(ctx, v38.0);
                            if let Some(v59) = v58 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);
                                let v138 = constructor_x64_and(ctx, v3, v60, v61);
                                let v139 = constructor_output_gpr(ctx, v138);
                                // Rule at src/isa/x64/lower.isle line 207.
                                return Some(v139);
                            }
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v136 = constructor_x64_and(ctx, v3, v41, v42);
                            let v137 = constructor_output_gpr(ctx, v136);
                            // Rule at src/isa/x64/lower.isle line 200.
                            return Some(v137);
                        }
                    }
                }
                &Opcode::Bor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v190 = C::put_in_regs(ctx, v38.1);
                            let v191 = constructor_or_i128(ctx, v78, v190);
                            let v192 = C::output(ctx, v191);
                            // Rule at src/isa/x64/lower.isle line 324.
                            return Some(v192);
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v188 = constructor_sse_or(ctx, v3, v68, v69);
                            let v189 = constructor_output_xmm(ctx, v188);
                            // Rule at src/isa/x64/lower.isle line 309.
                            return Some(v189);
                        }
                        let v144 = C::ty_scalar_float(ctx, v3);
                        if let Some(v145) = v144 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v186 = constructor_sse_or(ctx, v145, v68, v69);
                            let v187 = constructor_output_xmm(ctx, v186);
                            // Rule at src/isa/x64/lower.isle line 297.
                            return Some(v187);
                        }
                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v135) = v134 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v140 = &C::simm32_from_value(ctx, v38.0);
                            if let Some(v141) = v140 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v184 = constructor_x64_or(ctx, v3, v60, v141);
                                let v185 = constructor_output_gpr(ctx, v184);
                                // Rule at src/isa/x64/lower.isle line 291.
                                return Some(v185);
                            }
                            let v58 = &C::sinkable_load(ctx, v38.0);
                            if let Some(v59) = v58 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);
                                let v182 = constructor_x64_or(ctx, v3, v60, v61);
                                let v183 = constructor_output_gpr(ctx, v182);
                                // Rule at src/isa/x64/lower.isle line 287.
                                return Some(v183);
                            }
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v180 = constructor_x64_or(ctx, v3, v41, v42);
                            let v181 = constructor_output_gpr(ctx, v180);
                            // Rule at src/isa/x64/lower.isle line 280.
                            return Some(v181);
                        }
                    }
                }
                &Opcode::Bxor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v80 = constructor_value_regs_get_gpr(ctx, v78, 0x0);
                            let v82 = constructor_value_regs_get_gpr(ctx, v78, 0x1);
                            let v83 = C::put_in_regs(ctx, v38.1);
                            let v84 = constructor_value_regs_get_gpr(ctx, v83, 0x0);
                            let v85 = constructor_value_regs_get_gpr(ctx, v83, 0x1);
                            let v86 = &C::gpr_to_gpr_mem_imm(ctx, v84);
                            let v203 = constructor_x64_xor(ctx, I64, v80, v86);
                            let v88 = &C::gpr_to_gpr_mem_imm(ctx, v85);
                            let v204 = constructor_x64_xor(ctx, I64, v82, v88);
                            let v205 = constructor_value_gprs(ctx, v203, v204);
                            let v206 = C::output(ctx, v205);
                            // Rule at src/isa/x64/lower.isle line 359.
                            return Some(v206);
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v201 = constructor_x64_xor_vector(ctx, v3, v68, v69);
                            let v202 = constructor_output_xmm(ctx, v201);
                            // Rule at src/isa/x64/lower.isle line 354.
                            return Some(v202);
                        }
                        let v144 = C::ty_scalar_float(ctx, v3);
                        if let Some(v145) = v144 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v68 = constructor_put_in_xmm(ctx, v38.0);
                            let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                            let v199 = constructor_x64_xor_vector(ctx, v145, v68, v69);
                            let v200 = constructor_output_xmm(ctx, v199);
                            // Rule at src/isa/x64/lower.isle line 349.
                            return Some(v200);
                        }
                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v135) = v134 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v140 = &C::simm32_from_value(ctx, v38.0);
                            if let Some(v141) = v140 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v197 = constructor_x64_xor(ctx, v3, v60, v141);
                                let v198 = constructor_output_gpr(ctx, v197);
                                // Rule at src/isa/x64/lower.isle line 343.
                                return Some(v198);
                            }
                            let v58 = &C::sinkable_load(ctx, v38.0);
                            if let Some(v59) = v58 {
                                let v60 = constructor_put_in_gpr(ctx, v38.1);
                                let v61 = &constructor_sink_load_to_gpr_mem_imm(ctx, v59);
                                let v195 = constructor_x64_xor(ctx, v3, v60, v61);
                                let v196 = constructor_output_gpr(ctx, v195);
                                // Rule at src/isa/x64/lower.isle line 339.
                                return Some(v196);
                            }
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v42 = &constructor_put_in_gpr_mem_imm(ctx, v38.1);
                            let v193 = constructor_x64_xor(ctx, v3, v41, v42);
                            let v194 = constructor_output_gpr(ctx, v193);
                            // Rule at src/isa/x64/lower.isle line 332.
                            return Some(v194);
                        }
                    }
                }
                &Opcode::Rotl => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v284 = constructor_lo_gpr(ctx, v38.1);
                            let v285 = constructor_shl_i128(ctx, v78, v284);
                            let v287 = constructor_imm(ctx, I64, 0x80);
                            let v288 = C::gpr_new(ctx, v287);
                            let v289 = &C::gpr_to_gpr_mem_imm(ctx, v284);
                            let v290 = constructor_x64_sub(ctx, I64, v288, v289);
                            let v291 = constructor_shr_i128(ctx, v78, v290);
                            let v292 = constructor_or_i128(ctx, v285, v291);
                            let v293 = C::output(ctx, v292);
                            // Rule at src/isa/x64/lower.isle line 716.
                            return Some(v293);
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);
                            let v282 = constructor_x64_rotl(ctx, v5, v41, v207);
                            let v283 = constructor_output_gpr(ctx, v282);
                            // Rule at src/isa/x64/lower.isle line 710.
                            return Some(v283);
                        }
                    }
                }
                &Opcode::Rotr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v78 = C::put_in_regs(ctx, v38.0);
                            let v284 = constructor_lo_gpr(ctx, v38.1);
                            let v296 = constructor_shr_i128(ctx, v78, v284);
                            let v287 = constructor_imm(ctx, I64, 0x80);
                            let v288 = C::gpr_new(ctx, v287);
                            let v289 = &C::gpr_to_gpr_mem_imm(ctx, v284);
                            let v290 = constructor_x64_sub(ctx, I64, v288, v289);
                            let v297 = constructor_shl_i128(ctx, v78, v290);
                            let v298 = constructor_or_i128(ctx, v296, v297);
                            let v299 = C::output(ctx, v298);
                            // Rule at src/isa/x64/lower.isle line 737.
                            return Some(v299);
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);
                            let v294 = constructor_x64_rotr(ctx, v5, v41, v207);
                            let v295 = constructor_output_gpr(ctx, v294);
                            // Rule at src/isa/x64/lower.isle line 731.
                            return Some(v295);
                        }
                    }
                }
                &Opcode::Ishl => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v210 = constructor_lo_gpr(ctx, v38.1);
                                let v211 = C::put_in_regs(ctx, v38.0);
                                let v212 = constructor_shl_i128(ctx, v211, v210);
                                let v213 = C::output(ctx, v212);
                                // Rule at src/isa/x64/lower.isle line 412.
                                return Some(v213);
                            }
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v214 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v215 = constructor_put_in_xmm(ctx, v38.0);
                                let v216 = &constructor_mov_rmi_to_xmm(ctx, v214);
                                let v217 = constructor_x64_psllw(ctx, v215, v216);
                                let v218 = &constructor_ishl_i8x16_mask(ctx, v214);
                                let v221 = constructor_x64_load(ctx, I8X16, v218, &ExtKind::None);
                                let v222 = RegMem::Reg { reg: v221 };
                                let v223 = &C::reg_mem_to_xmm_mem(ctx, &v222);
                                let v224 = constructor_sse_and(ctx, I8X16, v217, v223);
                                let v225 = constructor_output_xmm(ctx, v224);
                                // Rule at src/isa/x64/lower.isle line 424.
                                return Some(v225);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v228 = constructor_x64_psllw(ctx, v68, v227);
                                let v229 = constructor_output_xmm(ctx, v228);
                                // Rule at src/isa/x64/lower.isle line 469.
                                return Some(v229);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v230 = constructor_x64_pslld(ctx, v68, v227);
                                let v231 = constructor_output_xmm(ctx, v230);
                                // Rule at src/isa/x64/lower.isle line 472.
                                return Some(v231);
                            }
                            I64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v232 = constructor_x64_psllq(ctx, v68, v227);
                                let v233 = constructor_output_xmm(ctx, v232);
                                // Rule at src/isa/x64/lower.isle line 475.
                                return Some(v233);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v41 = constructor_put_in_gpr(ctx, v38.0);
                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);
                            let v208 = constructor_x64_shl(ctx, v5, v41, v207);
                            let v209 = constructor_output_gpr(ctx, v208);
                            // Rule at src/isa/x64/lower.isle line 373.
                            return Some(v209);
                        }
                    }
                }
                &Opcode::Ushr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v210 = constructor_lo_gpr(ctx, v38.1);
                                let v211 = C::put_in_regs(ctx, v38.0);
                                let v238 = constructor_shr_i128(ctx, v211, v210);
                                let v239 = C::output(ctx, v238);
                                // Rule at src/isa/x64/lower.isle line 519.
                                return Some(v239);
                            }
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v214 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v215 = constructor_put_in_xmm(ctx, v38.0);
                                let v216 = &constructor_mov_rmi_to_xmm(ctx, v214);
                                let v240 = constructor_x64_psrlw(ctx, v215, v216);
                                let v241 = &constructor_ushr_i8x16_mask(ctx, v214);
                                let v242 = &constructor_synthetic_amode_to_xmm_mem(ctx, v241);
                                let v243 = constructor_sse_and(ctx, I8X16, v240, v242);
                                let v244 = constructor_output_xmm(ctx, v243);
                                // Rule at src/isa/x64/lower.isle line 529.
                                return Some(v244);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v245 = constructor_x64_psrlw(ctx, v68, v227);
                                let v246 = constructor_output_xmm(ctx, v245);
                                // Rule at src/isa/x64/lower.isle line 575.
                                return Some(v246);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v247 = constructor_x64_psrld(ctx, v68, v227);
                                let v248 = constructor_output_xmm(ctx, v247);
                                // Rule at src/isa/x64/lower.isle line 578.
                                return Some(v248);
                            }
                            I64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v249 = constructor_x64_psrlq(ctx, v68, v227);
                                let v250 = constructor_output_xmm(ctx, v249);
                                // Rule at src/isa/x64/lower.isle line 581.
                                return Some(v250);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v235 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Zero);
                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);
                            let v236 = constructor_x64_shr(ctx, v5, v235, v207);
                            let v237 = constructor_output_gpr(ctx, v236);
                            // Rule at src/isa/x64/lower.isle line 482.
                            return Some(v237);
                        }
                    }
                }
                &Opcode::Sshr => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I128 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v210 = constructor_lo_gpr(ctx, v38.1);
                                let v211 = C::put_in_regs(ctx, v38.0);
                                let v255 = constructor_sar_i128(ctx, v211, v210);
                                let v256 = C::output(ctx, v255);
                                // Rule at src/isa/x64/lower.isle line 631.
                                return Some(v256);
                            }
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v257 = &C::xmm_to_xmm_mem(ctx, v68);
                                let v258 = constructor_x64_punpcklbw(ctx, v68, v257);
                                let v259 = &C::xmm_to_xmm_mem(ctx, v68);
                                let v260 = constructor_x64_punpckhbw(ctx, v68, v259);
                                let v92 = C::value_type(ctx, v38.1);
                                let v261 = &constructor_sshr_i8x16_bigger_shift(ctx, v92, v226);
                                let v262 = constructor_x64_psraw(ctx, v258, v261);
                                let v263 = constructor_x64_psraw(ctx, v260, v261);
                                let v264 = &C::xmm_to_xmm_mem(ctx, v263);
                                let v265 = constructor_x64_packsswb(ctx, v262, v264);
                                let v266 = constructor_output_xmm(ctx, v265);
                                // Rule at src/isa/x64/lower.isle line 652.
                                return Some(v266);
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v267 = constructor_x64_psraw(ctx, v68, v227);
                                let v268 = constructor_output_xmm(ctx, v267);
                                // Rule at src/isa/x64/lower.isle line 681.
                                return Some(v268);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v226 = &constructor_mask_xmm_shift(ctx, v3, v38.1);
                                let v227 = &constructor_mov_rmi_to_xmm(ctx, v226);
                                let v269 = constructor_x64_psrad(ctx, v68, v227);
                                let v270 = constructor_output_xmm(ctx, v269);
                                // Rule at src/isa/x64/lower.isle line 684.
                                return Some(v270);
                            }
                            I64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v272 = constructor_x64_pextrq(ctx, v68, 0x0);
                                let v274 = constructor_x64_pextrq(ctx, v68, 0x1);
                                let v275 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, I64);
                                let v276 = constructor_x64_sar(ctx, I64, v272, v275);
                                let v277 = constructor_x64_sar(ctx, I64, v274, v275);
                                let v278 = &C::gpr_to_gpr_mem(ctx, v276);
                                let v279 = &C::gpr_to_gpr_mem(ctx, v277);
                                let v280 = constructor_make_i64x2_from_lanes(ctx, v278, v279);
                                let v281 = constructor_output_xmm(ctx, v280);
                                // Rule at src/isa/x64/lower.isle line 695.
                                return Some(v281);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v252 = constructor_extend_to_gpr(ctx, v38.0, v5, &ExtendKind::Sign);
                            let v207 = &constructor_put_masked_in_imm8_gpr(ctx, v38.1, v5);
                            let v253 = constructor_x64_sar(ctx, v5, v252, v207);
                            let v254 = constructor_output_gpr(ctx, v253);
                            // Rule at src/isa/x64/lower.isle line 594.
                            return Some(v254);
                        }
                    }
                }
                &Opcode::Fadd => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1025 = constructor_x64_addss(ctx, v1013, v1024);
                                    let v1026 = constructor_output_xmm(ctx, v1025);
                                    // Rule at src/isa/x64/lower.isle line 2041.
                                    return Some(v1026);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1016 = constructor_x64_addss(ctx, v68, v69);
                                let v1017 = constructor_output_xmm(ctx, v1016);
                                // Rule at src/isa/x64/lower.isle line 2030.
                                return Some(v1017);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1027 = constructor_x64_addsd(ctx, v1013, v1024);
                                    let v1028 = constructor_output_xmm(ctx, v1027);
                                    // Rule at src/isa/x64/lower.isle line 2043.
                                    return Some(v1028);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1018 = constructor_x64_addsd(ctx, v68, v69);
                                let v1019 = constructor_output_xmm(ctx, v1018);
                                // Rule at src/isa/x64/lower.isle line 2032.
                                return Some(v1019);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1029 = constructor_x64_addps(ctx, v1013, v1024);
                                    let v1030 = constructor_output_xmm(ctx, v1029);
                                    // Rule at src/isa/x64/lower.isle line 2045.
                                    return Some(v1030);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1020 = constructor_x64_addps(ctx, v68, v69);
                                let v1021 = constructor_output_xmm(ctx, v1020);
                                // Rule at src/isa/x64/lower.isle line 2034.
                                return Some(v1021);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1031 = constructor_x64_addpd(ctx, v1013, v1024);
                                    let v1032 = constructor_output_xmm(ctx, v1031);
                                    // Rule at src/isa/x64/lower.isle line 2047.
                                    return Some(v1032);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1022 = constructor_x64_addpd(ctx, v68, v69);
                                let v1023 = constructor_output_xmm(ctx, v1022);
                                // Rule at src/isa/x64/lower.isle line 2036.
                                return Some(v1023);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fsub => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1033 = constructor_x64_subss(ctx, v68, v69);
                                let v1034 = constructor_output_xmm(ctx, v1033);
                                // Rule at src/isa/x64/lower.isle line 2052.
                                return Some(v1034);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1035 = constructor_x64_subsd(ctx, v68, v69);
                                let v1036 = constructor_output_xmm(ctx, v1035);
                                // Rule at src/isa/x64/lower.isle line 2054.
                                return Some(v1036);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1037 = constructor_x64_subps(ctx, v68, v69);
                                let v1038 = constructor_output_xmm(ctx, v1037);
                                // Rule at src/isa/x64/lower.isle line 2056.
                                return Some(v1038);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1039 = constructor_x64_subpd(ctx, v68, v69);
                                let v1040 = constructor_output_xmm(ctx, v1039);
                                // Rule at src/isa/x64/lower.isle line 2058.
                                return Some(v1040);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmul => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1049 = constructor_x64_mulss(ctx, v1013, v1024);
                                    let v1050 = constructor_output_xmm(ctx, v1049);
                                    // Rule at src/isa/x64/lower.isle line 2074.
                                    return Some(v1050);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1041 = constructor_x64_mulss(ctx, v68, v69);
                                let v1042 = constructor_output_xmm(ctx, v1041);
                                // Rule at src/isa/x64/lower.isle line 2063.
                                return Some(v1042);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1051 = constructor_x64_mulsd(ctx, v1013, v1024);
                                    let v1052 = constructor_output_xmm(ctx, v1051);
                                    // Rule at src/isa/x64/lower.isle line 2076.
                                    return Some(v1052);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1043 = constructor_x64_mulsd(ctx, v68, v69);
                                let v1044 = constructor_output_xmm(ctx, v1043);
                                // Rule at src/isa/x64/lower.isle line 2065.
                                return Some(v1044);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1053 = constructor_x64_mulps(ctx, v1013, v1024);
                                    let v1054 = constructor_output_xmm(ctx, v1053);
                                    // Rule at src/isa/x64/lower.isle line 2078.
                                    return Some(v1054);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1045 = constructor_x64_mulps(ctx, v68, v69);
                                let v1046 = constructor_output_xmm(ctx, v1045);
                                // Rule at src/isa/x64/lower.isle line 2067.
                                return Some(v1046);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v58 = &C::sinkable_load(ctx, v38.0);
                                if let Some(v59) = v58 {
                                    let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                    let v1024 = &constructor_sink_load_to_xmm_mem(ctx, v59);
                                    let v1055 = constructor_x64_mulpd(ctx, v1013, v1024);
                                    let v1056 = constructor_output_xmm(ctx, v1055);
                                    // Rule at src/isa/x64/lower.isle line 2080.
                                    return Some(v1056);
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1047 = constructor_x64_mulpd(ctx, v68, v69);
                                let v1048 = constructor_output_xmm(ctx, v1047);
                                // Rule at src/isa/x64/lower.isle line 2069.
                                return Some(v1048);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fdiv => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1057 = constructor_x64_divss(ctx, v68, v69);
                                let v1058 = constructor_output_xmm(ctx, v1057);
                                // Rule at src/isa/x64/lower.isle line 2085.
                                return Some(v1058);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1059 = constructor_x64_divsd(ctx, v68, v69);
                                let v1060 = constructor_output_xmm(ctx, v1059);
                                // Rule at src/isa/x64/lower.isle line 2087.
                                return Some(v1060);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1061 = constructor_x64_divps(ctx, v68, v69);
                                let v1062 = constructor_output_xmm(ctx, v1061);
                                // Rule at src/isa/x64/lower.isle line 2089.
                                return Some(v1062);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1063 = constructor_x64_divpd(ctx, v68, v69);
                                let v1064 = constructor_output_xmm(ctx, v1063);
                                // Rule at src/isa/x64/lower.isle line 2091.
                                return Some(v1064);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fcopysign => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == F32 {
                                    let v1798 = constructor_imm(ctx, F32, 0x80000000);
                                    let v1799 = C::xmm_new(ctx, v1798);
                                    let v1800 = &C::put_in_xmm_mem(ctx, v38.0);
                                    let v1801 = constructor_x64_andnps(ctx, v1799, v1800);
                                    let v1802 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1803 = constructor_x64_andps(ctx, v1799, v1802);
                                    let v1804 = &C::xmm_to_xmm_mem(ctx, v1803);
                                    let v1805 = constructor_x64_orps(ctx, v1801, v1804);
                                    let v1806 = constructor_output_xmm(ctx, v1805);
                                    // Rule at src/isa/x64/lower.isle line 3275.
                                    return Some(v1806);
                                }
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == F64 {
                                    let v1807 = constructor_imm(ctx, F64, 0x8000000000000000);
                                    let v1808 = C::xmm_new(ctx, v1807);
                                    let v1800 = &C::put_in_xmm_mem(ctx, v38.0);
                                    let v1809 = constructor_x64_andnpd(ctx, v1808, v1800);
                                    let v1802 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1810 = constructor_x64_andpd(ctx, v1808, v1802);
                                    let v1811 = &C::xmm_to_xmm_mem(ctx, v1810);
                                    let v1812 = constructor_x64_orpd(ctx, v1809, v1811);
                                    let v1813 = constructor_output_xmm(ctx, v1812);
                                    // Rule at src/isa/x64/lower.isle line 3281.
                                    return Some(v1813);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmin => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v366 = constructor_put_in_xmm(ctx, v38.1);
                                let v1083 = constructor_xmm_min_max_seq(ctx, F32, true, v68, v366);
                                let v1084 = constructor_output_xmm(ctx, v1083);
                                // Rule at src/isa/x64/lower.isle line 2122.
                                return Some(v1084);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v366 = constructor_put_in_xmm(ctx, v38.1);
                                let v1085 = constructor_xmm_min_max_seq(ctx, F64, true, v68, v366);
                                let v1086 = constructor_output_xmm(ctx, v1085);
                                // Rule at src/isa/x64/lower.isle line 2124.
                                return Some(v1086);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1087 = constructor_x64_minps(ctx, v68, v69);
                                let v1088 = constructor_put_in_xmm(ctx, v38.1);
                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1090 = constructor_x64_minps(ctx, v1088, v1089);
                                let v1091 = &C::xmm_to_xmm_mem(ctx, v1090);
                                let v1092 = constructor_x64_orps(ctx, v1087, v1091);
                                let v1093 = &C::xmm_to_xmm_mem(ctx, v1090);
                                let v1094 =
                                    constructor_x64_cmpps(ctx, v1092, v1093, &FcmpImm::Unordered);
                                let v1095 = &C::xmm_to_xmm_mem(ctx, v1094);
                                let v1096 = constructor_x64_orps(ctx, v1092, v1095);
                                let v1098 = &C::xmi_imm(ctx, 0xA);
                                let v1099 = constructor_x64_psrld(ctx, v1094, v1098);
                                let v1100 = &C::xmm_to_xmm_mem(ctx, v1096);
                                let v1101 = constructor_x64_andnps(ctx, v1099, v1100);
                                let v1102 = constructor_output_xmm(ctx, v1101);
                                // Rule at src/isa/x64/lower.isle line 2139.
                                return Some(v1102);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1103 = constructor_x64_minpd(ctx, v68, v69);
                                let v1088 = constructor_put_in_xmm(ctx, v38.1);
                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1104 = constructor_x64_minpd(ctx, v1088, v1089);
                                let v1105 = &C::xmm_to_xmm_mem(ctx, v1104);
                                let v1106 = constructor_x64_orpd(ctx, v1103, v1105);
                                let v1107 = &C::xmm_to_xmm_mem(ctx, v1104);
                                let v1108 =
                                    constructor_x64_cmppd(ctx, v1103, v1107, &FcmpImm::Unordered);
                                let v1109 = &C::xmm_to_xmm_mem(ctx, v1108);
                                let v1110 = constructor_x64_orpd(ctx, v1106, v1109);
                                let v1112 = &C::xmi_imm(ctx, 0xD);
                                let v1113 = constructor_x64_psrlq(ctx, v1108, v1112);
                                let v1114 = &C::xmm_to_xmm_mem(ctx, v1110);
                                let v1115 = constructor_x64_andnpd(ctx, v1113, v1114);
                                let v1116 = constructor_output_xmm(ctx, v1115);
                                // Rule at src/isa/x64/lower.isle line 2182.
                                return Some(v1116);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FminPseudo => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1152 = constructor_x64_minss(ctx, v1013, v160);
                                let v1153 = constructor_output_xmm(ctx, v1152);
                                // Rule at src/isa/x64/lower.isle line 2291.
                                return Some(v1153);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1154 = constructor_x64_minsd(ctx, v1013, v160);
                                let v1155 = constructor_output_xmm(ctx, v1154);
                                // Rule at src/isa/x64/lower.isle line 2293.
                                return Some(v1155);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1156 = constructor_x64_minps(ctx, v1013, v160);
                                let v1157 = constructor_output_xmm(ctx, v1156);
                                // Rule at src/isa/x64/lower.isle line 2295.
                                return Some(v1157);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1158 = constructor_x64_minpd(ctx, v1013, v160);
                                let v1159 = constructor_output_xmm(ctx, v1158);
                                // Rule at src/isa/x64/lower.isle line 2297.
                                return Some(v1159);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fmax => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v366 = constructor_put_in_xmm(ctx, v38.1);
                                let v1118 = constructor_xmm_min_max_seq(ctx, F32, false, v68, v366);
                                let v1119 = constructor_output_xmm(ctx, v1118);
                                // Rule at src/isa/x64/lower.isle line 2194.
                                return Some(v1119);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v366 = constructor_put_in_xmm(ctx, v38.1);
                                let v1120 = constructor_xmm_min_max_seq(ctx, F64, false, v68, v366);
                                let v1121 = constructor_output_xmm(ctx, v1120);
                                // Rule at src/isa/x64/lower.isle line 2196.
                                return Some(v1121);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1122 = constructor_x64_maxps(ctx, v68, v69);
                                let v1088 = constructor_put_in_xmm(ctx, v38.1);
                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1123 = constructor_x64_maxps(ctx, v1088, v1089);
                                let v1124 = &C::xmm_to_xmm_mem(ctx, v1123);
                                let v1125 = constructor_x64_xorps(ctx, v1122, v1124);
                                let v1126 = &C::xmm_to_xmm_mem(ctx, v1125);
                                let v1127 = constructor_x64_orps(ctx, v1122, v1126);
                                let v1128 = &C::xmm_to_xmm_mem(ctx, v1125);
                                let v1129 = constructor_x64_subps(ctx, v1127, v1128);
                                let v1130 = &C::xmm_to_xmm_mem(ctx, v1127);
                                let v1131 =
                                    constructor_x64_cmpps(ctx, v1127, v1130, &FcmpImm::Unordered);
                                let v1132 = &C::xmi_imm(ctx, 0xA);
                                let v1133 = constructor_x64_psrld(ctx, v1131, v1132);
                                let v1134 = &C::xmm_to_xmm_mem(ctx, v1129);
                                let v1135 = constructor_x64_andnps(ctx, v1133, v1134);
                                let v1136 = constructor_output_xmm(ctx, v1135);
                                // Rule at src/isa/x64/lower.isle line 2202.
                                return Some(v1136);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1137 = constructor_x64_maxpd(ctx, v68, v69);
                                let v1088 = constructor_put_in_xmm(ctx, v38.1);
                                let v1089 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1138 = constructor_x64_maxpd(ctx, v1088, v1089);
                                let v1139 = &C::xmm_to_xmm_mem(ctx, v1138);
                                let v1140 = constructor_x64_xorpd(ctx, v1137, v1139);
                                let v1141 = &C::xmm_to_xmm_mem(ctx, v1140);
                                let v1142 = constructor_x64_orpd(ctx, v1137, v1141);
                                let v1143 = &C::xmm_to_xmm_mem(ctx, v1140);
                                let v1144 = constructor_x64_subpd(ctx, v1142, v1143);
                                let v1145 = &C::xmm_to_xmm_mem(ctx, v1142);
                                let v1146 =
                                    constructor_x64_cmppd(ctx, v1142, v1145, &FcmpImm::Unordered);
                                let v1147 = &C::xmi_imm(ctx, 0xD);
                                let v1148 = constructor_x64_psrlq(ctx, v1146, v1147);
                                let v1149 = &C::xmm_to_xmm_mem(ctx, v1144);
                                let v1150 = constructor_x64_andnpd(ctx, v1148, v1149);
                                let v1151 = constructor_output_xmm(ctx, v1150);
                                // Rule at src/isa/x64/lower.isle line 2245.
                                return Some(v1151);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::FmaxPseudo => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1160 = constructor_x64_maxss(ctx, v1013, v160);
                                let v1161 = constructor_output_xmm(ctx, v1160);
                                // Rule at src/isa/x64/lower.isle line 2302.
                                return Some(v1161);
                            }
                            F64 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1162 = constructor_x64_maxsd(ctx, v1013, v160);
                                let v1163 = constructor_output_xmm(ctx, v1162);
                                // Rule at src/isa/x64/lower.isle line 2304.
                                return Some(v1163);
                            }
                            F32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1164 = constructor_x64_maxps(ctx, v1013, v160);
                                let v1165 = constructor_output_xmm(ctx, v1164);
                                // Rule at src/isa/x64/lower.isle line 2306.
                                return Some(v1165);
                            }
                            F64X2 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1013 = constructor_put_in_xmm(ctx, v38.1);
                                let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                                let v1166 = constructor_x64_maxpd(ctx, v1013, v160);
                                let v1167 = constructor_output_xmm(ctx, v1166);
                                // Rule at src/isa/x64/lower.isle line 2308.
                                return Some(v1167);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Snarrow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == I16X8 {
                                    let v68 = constructor_put_in_xmm(ctx, v38.0);
                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1757 = constructor_x64_packsswb(ctx, v68, v69);
                                    let v1758 = constructor_output_xmm(ctx, v1757);
                                    // Rule at src/isa/x64/lower.isle line 3202.
                                    return Some(v1758);
                                }
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == I32X4 {
                                    let v68 = constructor_put_in_xmm(ctx, v38.0);
                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1759 = constructor_x64_packssdw(ctx, v68, v69);
                                    let v1760 = constructor_output_xmm(ctx, v1759);
                                    // Rule at src/isa/x64/lower.isle line 3205.
                                    return Some(v1760);
                                }
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v154 = C::def_inst(ctx, v38.1);
                                if let Some(v155) = v154 {
                                    let v156 = &C::inst_data(ctx, v155);
                                    if let &InstructionData::UnaryConst {
                                        opcode: ref v1764,
                                        constant_handle: v1765,
                                    } = v156
                                    {
                                        if let &Opcode::Vconst = v1764 {
                                            let v163 = C::def_inst(ctx, v38.0);
                                            if let Some(v164) = v163 {
                                                let v165 = &C::inst_data(ctx, v164);
                                                if let &InstructionData::Unary {
                                                    opcode: ref v166,
                                                    arg: v167,
                                                } = v165
                                                {
                                                    match v166 {
                                                        &Opcode::FcvtToSintSat => {
                                                            let v1761 = C::first_result(ctx, v164);
                                                            if let Some(v1762) = v1761 {
                                                                let v1763 =
                                                                    C::value_type(ctx, v1762);
                                                                if v1763 == I64X2 {
                                                                    let v1766 =
                                                                        C::u128_from_constant(
                                                                            ctx, v1765,
                                                                        );
                                                                    if let Some(v1767) = v1766 {
                                                                        if v1767 == 0x0 {
                                                                            let v168 = constructor_put_in_xmm(ctx, v167);
                                                                            let v397 =
                                                                                &C::xmm_to_xmm_mem(
                                                                                    ctx, v168,
                                                                                );
                                                                            let v1768 = constructor_x64_cmppd(ctx, v168, v397, &FcmpImm::Equal);
                                                                            let v1769 = C::snarrow_umax_mask(ctx);
                                                                            let v1770 = &constructor_const_to_xmm_mem(ctx, v1769);
                                                                            let v1771 = constructor_x64_andps(ctx, v1768, v1770);
                                                                            let v1772 =
                                                                                &C::xmm_to_xmm_mem(
                                                                                    ctx, v1771,
                                                                                );
                                                                            let v1773 = constructor_x64_minpd(ctx, v168, v1772);
                                                                            let v1774 =
                                                                                &C::xmm_to_xmm_mem(
                                                                                    ctx, v1773,
                                                                                );
                                                                            let v1775 = constructor_x64_cvttpd2dq(ctx, v1774);
                                                                            let v1776 = constructor_output_xmm(ctx, v1775);
                                                                            // Rule at src/isa/x64/lower.isle line 3214.
                                                                            return Some(v1776);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        &Opcode::X86Cvtt2dq => {
                                                            let v1761 = C::first_result(ctx, v164);
                                                            if let Some(v1762) = v1761 {
                                                                let v1763 =
                                                                    C::value_type(ctx, v1762);
                                                                if v1763 == I64X2 {
                                                                    let v1766 =
                                                                        C::u128_from_constant(
                                                                            ctx, v1765,
                                                                        );
                                                                    if let Some(v1767) = v1766 {
                                                                        if v1767 == 0x0 {
                                                                            let v418 =
                                                                                &C::put_in_xmm_mem(
                                                                                    ctx, v167,
                                                                                );
                                                                            let v1777 = constructor_x64_cvttpd2dq(ctx, v418);
                                                                            let v1778 = constructor_output_xmm(ctx, v1777);
                                                                            // Rule at src/isa/x64/lower.isle line 3236.
                                                                            return Some(v1778);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                        _ => {}
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Unarrow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == I16X8 {
                                    let v68 = constructor_put_in_xmm(ctx, v38.0);
                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1779 = constructor_x64_packuswb(ctx, v68, v69);
                                    let v1780 = constructor_output_xmm(ctx, v1779);
                                    // Rule at src/isa/x64/lower.isle line 3242.
                                    return Some(v1780);
                                }
                            }
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v1756 = C::value_type(ctx, v38.0);
                                if v1756 == I32X4 {
                                    let v68 = constructor_put_in_xmm(ctx, v38.0);
                                    let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                    let v1781 = constructor_x64_packusdw(ctx, v68, v69);
                                    let v1782 = constructor_output_xmm(ctx, v1781);
                                    // Rule at src/isa/x64/lower.isle line 3245.
                                    return Some(v1782);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Uunarrow => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v154 = C::def_inst(ctx, v38.1);
                    if let Some(v155) = v154 {
                        let v156 = &C::inst_data(ctx, v155);
                        if let &InstructionData::UnaryConst {
                            opcode: ref v1764,
                            constant_handle: v1765,
                        } = v156
                        {
                            if let &Opcode::Vconst = v1764 {
                                let v163 = C::def_inst(ctx, v38.0);
                                if let Some(v164) = v163 {
                                    let v165 = &C::inst_data(ctx, v164);
                                    if let &InstructionData::Unary {
                                        opcode: ref v166,
                                        arg: v167,
                                    } = v165
                                    {
                                        if let &Opcode::FcvtToUintSat = v166 {
                                            let v387 = C::value_type(ctx, v167);
                                            if v387 == F64X2 {
                                                let v1766 = C::u128_from_constant(ctx, v1765);
                                                if let Some(v1767) = v1766 {
                                                    if v1767 == 0x0 {
                                                        let v168 =
                                                            constructor_put_in_xmm(ctx, v167);
                                                        let v2232 =
                                                            constructor_xmm_zero(ctx, F64X2);
                                                        let v2233 = &C::xmm_to_xmm_mem(ctx, v2232);
                                                        let v2234 =
                                                            constructor_x64_maxpd(ctx, v168, v2233);
                                                        let v2235 = C::uunarrow_umax_mask(ctx);
                                                        let v2236 = &constructor_const_to_xmm_mem(
                                                            ctx, v2235,
                                                        );
                                                        let v2237 = constructor_x64_minpd(
                                                            ctx, v2234, v2236,
                                                        );
                                                        let v2238 = &C::xmm_to_xmm_mem(ctx, v2237);
                                                        let v2239 = constructor_x64_roundpd(
                                                            ctx,
                                                            v2238,
                                                            &RoundImm::RoundZero,
                                                        );
                                                        let v2240 = C::uunarrow_uint_mask(ctx);
                                                        let v2241 = &constructor_const_to_xmm_mem(
                                                            ctx, v2240,
                                                        );
                                                        let v2242 = constructor_x64_addpd(
                                                            ctx, v2239, v2241,
                                                        );
                                                        let v2243 = &C::xmm_to_xmm_mem(ctx, v2232);
                                                        let v2245 = constructor_x64_shufps(
                                                            ctx, v2242, v2243, 0x88,
                                                        );
                                                        let v2246 =
                                                            constructor_output_xmm(ctx, v2245);
                                                        // Rule at src/isa/x64/lower.isle line 3957.
                                                        return Some(v2246);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                &Opcode::IaddPairwise => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v154 = C::def_inst(ctx, v38.1);
                                if let Some(v155) = v154 {
                                    let v156 = &C::inst_data(ctx, v155);
                                    if let &InstructionData::Unary {
                                        opcode: ref v157,
                                        arg: v158,
                                    } = v156
                                    {
                                        match v157 {
                                            &Opcode::SwidenHigh => {
                                                let v163 = C::def_inst(ctx, v38.0);
                                                if let Some(v164) = v163 {
                                                    let v165 = &C::inst_data(ctx, v164);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v166,
                                                        arg: v167,
                                                    } = v165
                                                    {
                                                        if let &Opcode::SwidenLow = v166 {
                                                            if v158 == v167 {
                                                                let v387 = C::value_type(ctx, v167);
                                                                if v387 == I8X16 {
                                                                    let v1671 = C::iadd_pairwise_mul_const_16(ctx);
                                                                    let v1672 = constructor_x64_xmm_load_const(ctx, I8X16, v1671);
                                                                    let v1673 = &C::put_in_xmm_mem(
                                                                        ctx, v167,
                                                                    );
                                                                    let v1674 =
                                                                        constructor_x64_pmaddubsw(
                                                                            ctx, v1672, v1673,
                                                                        );
                                                                    let v1675 =
                                                                        constructor_output_xmm(
                                                                            ctx, v1674,
                                                                        );
                                                                    // Rule at src/isa/x64/lower.isle line 3108.
                                                                    return Some(v1675);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            &Opcode::UwidenHigh => {
                                                let v163 = C::def_inst(ctx, v38.0);
                                                if let Some(v164) = v163 {
                                                    let v165 = &C::inst_data(ctx, v164);
                                                    if let &InstructionData::Unary {
                                                        opcode: ref v166,
                                                        arg: v167,
                                                    } = v165
                                                    {
                                                        if let &Opcode::UwidenLow = v166 {
                                                            if v158 == v167 {
                                                                let v387 = C::value_type(ctx, v167);
                                                                if v387 == I8X16 {
                                                                    let v1671 = C::iadd_pairwise_mul_const_16(ctx);
                                                                    let v1681 = &constructor_const_to_xmm_mem(ctx, v1671);
                                                                    let v1678 =
                                                                        constructor_put_in_xmm(
                                                                            ctx, v167,
                                                                        );
                                                                    let v1682 =
                                                                        constructor_x64_pmaddubsw(
                                                                            ctx, v1678, v1681,
                                                                        );
                                                                    let v1683 =
                                                                        constructor_output_xmm(
                                                                            ctx, v1682,
                                                                        );
                                                                    // Rule at src/isa/x64/lower.isle line 3124.
                                                                    return Some(v1683);
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1667 = constructor_x64_phaddw(ctx, v68, v69);
                                let v1668 = constructor_output_xmm(ctx, v1667);
                                // Rule at src/isa/x64/lower.isle line 3101.
                                return Some(v1668);
                            }
                            I32X4 => {
                                let v38 = C::unpack_value_array_2(ctx, v37);
                                let v154 = C::def_inst(ctx, v38.1);
                                if let Some(v155) = v154 {
                                    let v156 = &C::inst_data(ctx, v155);
                                    match v156 {
                                        &InstructionData::Binary {
                                            opcode: ref v1709,
                                            args: ref v1710,
                                        } => {
                                            if let &Opcode::Imul = v1709 {
                                                let v163 = C::def_inst(ctx, v38.0);
                                                if let Some(v164) = v163 {
                                                    let v165 = &C::inst_data(ctx, v164);
                                                    if let &InstructionData::Binary {
                                                        opcode: ref v1694,
                                                        args: ref v1695,
                                                    } = v165
                                                    {
                                                        if let &Opcode::Imul = v1694 {
                                                            let v1696 =
                                                                C::unpack_value_array_2(ctx, v1695);
                                                            let v1699 = C::def_inst(ctx, v1696.0);
                                                            if let Some(v1700) = v1699 {
                                                                let v1701 =
                                                                    &C::inst_data(ctx, v1700);
                                                                if let &InstructionData::Unary {
                                                                    opcode: ref v1702,
                                                                    arg: v1703,
                                                                } = v1701
                                                                {
                                                                    if let &Opcode::SwidenLow =
                                                                        v1702
                                                                    {
                                                                        let v1704 = C::def_inst(
                                                                            ctx, v1696.1,
                                                                        );
                                                                        if let Some(v1705) = v1704 {
                                                                            let v1706 =
                                                                                &C::inst_data(
                                                                                    ctx, v1705,
                                                                                );
                                                                            if let &InstructionData::Unary {
                                                                                opcode: ref v1707,
                                                                                arg: v1708,
                                                                            } = v1706 {
                                                                                if let &Opcode::SwidenLow = v1707 {
                                                                                    let v1711 = C::unpack_value_array_2(ctx, v1710);
                                                                                    let v1714 = C::def_inst(ctx, v1711.0);
                                                                                    if let Some(v1715) = v1714 {
                                                                                        let v1716 = &C::inst_data(ctx, v1715);
                                                                                        if let &InstructionData::Unary {
                                                                                            opcode: ref v1717,
                                                                                            arg: v1718,
                                                                                        } = v1716 {
                                                                                            if let &Opcode::SwidenHigh = v1717 {
                                                                                                if v1703 == v1718 {
                                                                                                    let v1719 = C::def_inst(ctx, v1711.1);
                                                                                                    if let Some(v1720) = v1719 {
                                                                                                        let v1721 = &C::inst_data(ctx, v1720);
                                                                                                        if let &InstructionData::Unary {
                                                                                                            opcode: ref v1722,
                                                                                                            arg: v1723,
                                                                                                        } = v1721 {
                                                                                                            if let &Opcode::SwidenHigh = v1722 {
                                                                                                                if v1708 == v1723 {
                                                                                                                    let v1724 = constructor_put_in_xmm(ctx, v1703);
                                                                                                                    let v1725 = &C::put_in_xmm_mem(ctx, v1708);
                                                                                                                    let v1726 = constructor_x64_pmaddwd(ctx, v1724, v1725);
                                                                                                                    let v1727 = constructor_output_xmm(ctx, v1726);
                                                                                                                    // Rule at src/isa/x64/lower.isle line 3146.
                                                                                                                    return Some(v1727);
                                                                                                                }
                                                                                                            }
                                                                                                        }
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        }
                                                                                    }
                                                                                }
                                                                            }
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &InstructionData::Unary {
                                            opcode: ref v157,
                                            arg: v158,
                                        } => {
                                            match v157 {
                                                &Opcode::SwidenHigh => {
                                                    let v163 = C::def_inst(ctx, v38.0);
                                                    if let Some(v164) = v163 {
                                                        let v165 = &C::inst_data(ctx, v164);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v166,
                                                            arg: v167,
                                                        } = v165
                                                        {
                                                            if let &Opcode::SwidenLow = v166 {
                                                                if v158 == v167 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    if v387 == I16X8 {
                                                                        let v1676 = C::iadd_pairwise_mul_const_32(ctx);
                                                                        let v1677 = &constructor_const_to_xmm_mem(ctx, v1676);
                                                                        let v1678 =
                                                                            constructor_put_in_xmm(
                                                                                ctx, v167,
                                                                            );
                                                                        let v1679 =
                                                                            constructor_x64_pmaddwd(
                                                                                ctx, v1678, v1677,
                                                                            );
                                                                        let v1680 =
                                                                            constructor_output_xmm(
                                                                                ctx, v1679,
                                                                            );
                                                                        // Rule at src/isa/x64/lower.isle line 3116.
                                                                        return Some(v1680);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                &Opcode::UwidenHigh => {
                                                    let v163 = C::def_inst(ctx, v38.0);
                                                    if let Some(v164) = v163 {
                                                        let v165 = &C::inst_data(ctx, v164);
                                                        if let &InstructionData::Unary {
                                                            opcode: ref v166,
                                                            arg: v167,
                                                        } = v165
                                                        {
                                                            if let &Opcode::UwidenLow = v166 {
                                                                if v158 == v167 {
                                                                    let v387 =
                                                                        C::value_type(ctx, v167);
                                                                    if v387 == I16X8 {
                                                                        let v1684 = C::iadd_pairwise_xor_const_32(ctx);
                                                                        let v1685 = &constructor_const_to_xmm_mem(ctx, v1684);
                                                                        let v1678 =
                                                                            constructor_put_in_xmm(
                                                                                ctx, v167,
                                                                            );
                                                                        let v1686 =
                                                                            constructor_x64_pxor(
                                                                                ctx, v1678, v1685,
                                                                            );
                                                                        let v1687 = C::iadd_pairwise_mul_const_32(ctx);
                                                                        let v1688 = &constructor_const_to_xmm_mem(ctx, v1687);
                                                                        let v1689 =
                                                                            constructor_x64_pmaddwd(
                                                                                ctx, v1686, v1688,
                                                                            );
                                                                        let v1690 = C::iadd_pairwise_addd_const_32(ctx);
                                                                        let v1691 = &constructor_const_to_xmm_mem(ctx, v1690);
                                                                        let v1692 =
                                                                            constructor_x64_paddd(
                                                                                ctx, v1689, v1691,
                                                                            );
                                                                        let v1693 =
                                                                            constructor_output_xmm(
                                                                                ctx, v1692,
                                                                            );
                                                                        // Rule at src/isa/x64/lower.isle line 3132.
                                                                        return Some(v1693);
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                _ => {}
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                let v68 = constructor_put_in_xmm(ctx, v38.0);
                                let v69 = &C::put_in_xmm_mem(ctx, v38.1);
                                let v1669 = constructor_x64_phaddd(ctx, v68, v69);
                                let v1670 = constructor_output_xmm(ctx, v1669);
                                // Rule at src/isa/x64/lower.isle line 3104.
                                return Some(v1670);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::X86Pmaddubsw => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v38 = C::unpack_value_array_2(ctx, v37);
                            let v1013 = constructor_put_in_xmm(ctx, v38.1);
                            let v160 = &C::put_in_xmm_mem(ctx, v38.0);
                            let v1014 = constructor_x64_pmaddubsw(ctx, v1013, v160);
                            let v1015 = constructor_output_xmm(ctx, v1014);
                            // Rule at src/isa/x64/lower.isle line 2025.
                            return Some(v1015);
                        }
                    }
                }
                &Opcode::Iconcat => {
                    let v38 = C::unpack_value_array_2(ctx, v37);
                    let v1756 = C::value_type(ctx, v38.0);
                    if v1756 == I64 {
                        let v2207 = C::put_in_reg(ctx, v38.0);
                        let v2208 = C::put_in_reg(ctx, v38.1);
                        let v2209 = C::value_regs(ctx, v2207, v2208);
                        let v2210 = C::output(ctx, v2209);
                        // Rule at src/isa/x64/lower.isle line 3905.
                        return Some(v2210);
                    }
                }
                _ => {}
            }
        }
        &InstructionData::BinaryImm8 {
            opcode: ref v2081,
            arg: v2082,
            imm: v2083,
        } => {
            if let &Opcode::Extractlane = v2081 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v2084 = C::u8_from_uimm8(ctx, v2083);
                    match v2084 {
                        0x0 => {
                            let v3 = C::value_type(ctx, v2);
                            let v144 = C::ty_scalar_float(ctx, v3);
                            if let Some(v145) = v144 {
                                let v2085 = constructor_output_value(ctx, v2082);
                                // Rule at src/isa/x64/lower.isle line 3716.
                                return Some(v2085);
                            }
                        }
                        0x1 => {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == F64 {
                                let v2086 = C::value_type(ctx, v2082);
                                let v2087 = C::ty_vec128(ctx, v2086);
                                if let Some(v2088) = v2087 {
                                    let v2089 = &C::put_in_xmm_mem(ctx, v2082);
                                    let v2092 = constructor_x64_pshufd(ctx, v2089, 0xEE);
                                    let v2093 = constructor_output_xmm(ctx, v2092);
                                    // Rule at src/isa/x64/lower.isle line 3725.
                                    return Some(v2093);
                                }
                            }
                        }
                        _ => {}
                    }
                    let v3 = C::value_type(ctx, v2);
                    if v3 == F32 {
                        let v2086 = C::value_type(ctx, v2082);
                        let v2087 = C::ty_vec128(ctx, v2086);
                        if let Some(v2088) = v2087 {
                            let v2089 = &C::put_in_xmm_mem(ctx, v2082);
                            let v2090 = constructor_x64_pshufd(ctx, v2089, v2084);
                            let v2091 = constructor_output_xmm(ctx, v2090);
                            // Rule at src/isa/x64/lower.isle line 3720.
                            return Some(v2091);
                        }
                    }
                }
                let v2086 = C::value_type(ctx, v2082);
                let v2094 = C::multi_lane(ctx, v2086);
                if let Some(v2095) = v2094 {
                    match v2095.0 {
                        0x8 => {
                            if v2095.1 == 0x10 {
                                let v2098 = constructor_put_in_xmm(ctx, v2082);
                                let v2084 = C::u8_from_uimm8(ctx, v2083);
                                let v2099 = constructor_x64_pextrb(ctx, v2098, v2084);
                                let v2100 = constructor_output_gpr(ctx, v2099);
                                // Rule at src/isa/x64/lower.isle line 3734.
                                return Some(v2100);
                            }
                        }
                        0x10 => {
                            if v2095.1 == 0x8 {
                                let v2098 = constructor_put_in_xmm(ctx, v2082);
                                let v2084 = C::u8_from_uimm8(ctx, v2083);
                                let v2101 = constructor_x64_pextrw(ctx, v2098, v2084);
                                let v2102 = constructor_output_gpr(ctx, v2101);
                                // Rule at src/isa/x64/lower.isle line 3739.
                                return Some(v2102);
                            }
                        }
                        0x20 => {
                            if v2095.1 == 0x4 {
                                let v2098 = constructor_put_in_xmm(ctx, v2082);
                                let v2084 = C::u8_from_uimm8(ctx, v2083);
                                let v2103 = constructor_x64_pextrd(ctx, v2098, v2084);
                                let v2104 = constructor_output_gpr(ctx, v2103);
                                // Rule at src/isa/x64/lower.isle line 3744.
                                return Some(v2104);
                            }
                        }
                        0x40 => {
                            if v2095.1 == 0x2 {
                                let v2098 = constructor_put_in_xmm(ctx, v2082);
                                let v2084 = C::u8_from_uimm8(ctx, v2083);
                                let v2105 = constructor_x64_pextrq(ctx, v2098, v2084);
                                let v2106 = constructor_output_gpr(ctx, v2105);
                                // Rule at src/isa/x64/lower.isle line 3747.
                                return Some(v2106);
                            }
                        }
                        _ => {}
                    }
                }
            }
        }
        &InstructionData::Call {
            opcode: ref v1515,
            args: v1516,
            func_ref: v1517,
        } => {
            if let &Opcode::Call = v1515 {
                let v1519 = C::func_ref_data(ctx, v1517);
                let v1518 = C::value_list_slice(ctx, v1516);
                let v1523 = C::gen_call(ctx, v1519.0, v1519.1, v1519.2, v1518);
                // Rule at src/isa/x64/lower.isle line 2771.
                return Some(v1523);
            }
        }
        &InstructionData::CallIndirect {
            opcode: ref v1524,
            args: v1525,
            sig_ref: v1526,
        } => {
            if let &Opcode::CallIndirect = v1524 {
                let v1527 = C::value_list_slice(ctx, v1525);
                let v1528 = C::value_slice_unwrap(ctx, v1527);
                if let Some(v1529) = v1528 {
                    let v1532 = C::gen_call_indirect(ctx, v1526, v1529.0, v1529.1);
                    // Rule at src/isa/x64/lower.isle line 2774.
                    return Some(v1532);
                }
            }
        }
        &InstructionData::FloatCompare {
            opcode: ref v759,
            args: ref v760,
            cond: ref v761,
        } => {
            if let &Opcode::Fcmp = v759 {
                match v761 {
                    &FloatCC::Equal => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v776 = constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Equal);
                            let v777 = constructor_output_xmm(ctx, v776);
                            // Rule at src/isa/x64/lower.isle line 1538.
                            return Some(v777);
                        }
                    }
                    &FloatCC::GreaterThan => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v799 = constructor_put_in_xmm(ctx, v762.1);
                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);
                            let v801 =
                                constructor_x64_cmpp(ctx, v772, v799, v800, &FcmpImm::LessThan);
                            let v802 = constructor_output_xmm(ctx, v801);
                            // Rule at src/isa/x64/lower.isle line 1558.
                            return Some(v802);
                        }
                    }
                    &FloatCC::GreaterThanOrEqual => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v799 = constructor_put_in_xmm(ctx, v762.1);
                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);
                            let v803 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v799,
                                v800,
                                &FcmpImm::LessThanOrEqual,
                            );
                            let v804 = constructor_output_xmm(ctx, v803);
                            // Rule at src/isa/x64/lower.isle line 1560.
                            return Some(v804);
                        }
                    }
                    &FloatCC::LessThan => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v782 =
                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::LessThan);
                            let v783 = constructor_output_xmm(ctx, v782);
                            // Rule at src/isa/x64/lower.isle line 1542.
                            return Some(v783);
                        }
                    }
                    &FloatCC::LessThanOrEqual => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v785 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v773,
                                v774,
                                &FcmpImm::LessThanOrEqual,
                            );
                            let v786 = constructor_output_xmm(ctx, v785);
                            // Rule at src/isa/x64/lower.isle line 1544.
                            return Some(v786);
                        }
                    }
                    &FloatCC::NotEqual => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v779 =
                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::NotEqual);
                            let v780 = constructor_output_xmm(ctx, v779);
                            // Rule at src/isa/x64/lower.isle line 1540.
                            return Some(v780);
                        }
                    }
                    &FloatCC::Ordered => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v788 =
                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Ordered);
                            let v789 = constructor_output_xmm(ctx, v788);
                            // Rule at src/isa/x64/lower.isle line 1546.
                            return Some(v789);
                        }
                    }
                    &FloatCC::Unordered => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v791 =
                                constructor_x64_cmpp(ctx, v772, v773, v774, &FcmpImm::Unordered);
                            let v792 = constructor_output_xmm(ctx, v791);
                            // Rule at src/isa/x64/lower.isle line 1548.
                            return Some(v792);
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThan => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v794 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v773,
                                v774,
                                &FcmpImm::UnorderedOrGreaterThan,
                            );
                            let v795 = constructor_output_xmm(ctx, v794);
                            // Rule at src/isa/x64/lower.isle line 1550.
                            return Some(v795);
                        }
                    }
                    &FloatCC::UnorderedOrGreaterThanOrEqual => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v773 = constructor_put_in_xmm(ctx, v762.0);
                            let v774 = &C::put_in_xmm_mem(ctx, v762.1);
                            let v797 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v773,
                                v774,
                                &FcmpImm::UnorderedOrGreaterThanOrEqual,
                            );
                            let v798 = constructor_output_xmm(ctx, v797);
                            // Rule at src/isa/x64/lower.isle line 1552.
                            return Some(v798);
                        }
                    }
                    &FloatCC::UnorderedOrLessThan => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v799 = constructor_put_in_xmm(ctx, v762.1);
                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);
                            let v805 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v799,
                                v800,
                                &FcmpImm::UnorderedOrGreaterThan,
                            );
                            let v806 = constructor_output_xmm(ctx, v805);
                            // Rule at src/isa/x64/lower.isle line 1562.
                            return Some(v806);
                        }
                    }
                    &FloatCC::UnorderedOrLessThanOrEqual => {
                        let v762 = C::unpack_value_array_2(ctx, v760);
                        let v765 = C::value_type(ctx, v762.0);
                        let v771 = C::ty_vec128(ctx, v765);
                        if let Some(v772) = v771 {
                            let v799 = constructor_put_in_xmm(ctx, v762.1);
                            let v800 = &C::put_in_xmm_mem(ctx, v762.0);
                            let v807 = constructor_x64_cmpp(
                                ctx,
                                v772,
                                v799,
                                v800,
                                &FcmpImm::UnorderedOrGreaterThanOrEqual,
                            );
                            let v808 = constructor_output_xmm(ctx, v807);
                            // Rule at src/isa/x64/lower.isle line 1564.
                            return Some(v808);
                        }
                    }
                    _ => {}
                }
                let v762 = C::unpack_value_array_2(ctx, v760);
                let v765 = C::value_type(ctx, v762.0);
                let v766 = C::ty_scalar_float(ctx, v765);
                if let Some(v767) = v766 {
                    let v768 = &constructor_emit_fcmp(ctx, v761, v762.0, v762.1);
                    let v769 = constructor_lower_fcmp_bool(ctx, v768);
                    let v770 = C::output(ctx, v769);
                    // Rule at src/isa/x64/lower.isle line 1531.
                    return Some(v770);
                }
            }
        }
        &InstructionData::FuncAddr {
            opcode: ref v1439,
            func_ref: v1440,
        } => {
            if let &Opcode::FuncAddr = v1439 {
                let v1441 = C::func_ref_data(ctx, v1440);
                let v1446 = constructor_load_ext_name(ctx, v1441.1, 0x0);
                let v1447 = constructor_output_reg(ctx, v1446);
                // Rule at src/isa/x64/lower.isle line 2713.
                return Some(v1447);
            }
        }
        &InstructionData::IntAddTrap {
            opcode: ref v622,
            args: ref v623,
            code: ref v624,
        } => {
            if let &Opcode::UaddOverflowTrap = v622 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v625 = C::unpack_value_array_2(ctx, v623);
                        let v641 = &C::sinkable_load(ctx, v625.0);
                        if let Some(v642) = v641 {
                            let v636 = constructor_put_in_gpr(ctx, v625.1);
                            let v643 = &constructor_sink_load_to_gpr_mem_imm(ctx, v642);
                            let v644 = &constructor_x64_add_with_flags_paired(ctx, v5, v636, v643);
                            let v631 = &constructor_trap_if(ctx, &CC::B, v624);
                            let v645 = constructor_with_flags(ctx, v644, v631);
                            let v646 = C::output(ctx, v645);
                            // Rule at src/isa/x64/lower.isle line 1384.
                            return Some(v646);
                        }
                        let v634 = &C::simm32_from_value(ctx, v625.0);
                        if let Some(v635) = v634 {
                            let v636 = constructor_put_in_gpr(ctx, v625.1);
                            let v637 = &constructor_x64_add_with_flags_paired(ctx, v5, v636, v635);
                            let v638 = &constructor_trap_if(ctx, &CC::B, v624);
                            let v639 = constructor_with_flags(ctx, v637, v638);
                            let v640 = C::output(ctx, v639);
                            // Rule at src/isa/x64/lower.isle line 1378.
                            return Some(v640);
                        }
                        let v628 = constructor_put_in_gpr(ctx, v625.0);
                        let v629 = &constructor_put_in_gpr_mem_imm(ctx, v625.1);
                        let v630 = &constructor_x64_add_with_flags_paired(ctx, v5, v628, v629);
                        let v631 = &constructor_trap_if(ctx, &CC::B, v624);
                        let v632 = constructor_with_flags(ctx, v630, v631);
                        let v633 = C::output(ctx, v632);
                        // Rule at src/isa/x64/lower.isle line 1370.
                        return Some(v633);
                    }
                }
            }
        }
        &InstructionData::IntCompare {
            opcode: ref v653,
            args: ref v654,
            cond: ref v655,
        } => {
            if let &Opcode::Icmp = v653 {
                match v655 {
                    &IntCC::Equal => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v711 = constructor_x64_pcmpeq(ctx, v708, v709, v710);
                            let v712 = constructor_output_xmm(ctx, v711);
                            // Rule at src/isa/x64/lower.isle line 1446.
                            return Some(v712);
                        }
                    }
                    &IntCC::NotEqual => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v711 = constructor_x64_pcmpeq(ctx, v708, v709, v710);
                            let v713 = constructor_vector_all_ones(ctx);
                            let v714 = &C::xmm_to_xmm_mem(ctx, v713);
                            let v715 = constructor_x64_pxor(ctx, v711, v714);
                            let v716 = constructor_output_xmm(ctx, v715);
                            // Rule at src/isa/x64/lower.isle line 1451.
                            return Some(v716);
                        }
                    }
                    &IntCC::SignedGreaterThan => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v656 = C::unpack_value_array_2(ctx, v654);
                                let v677 = C::def_inst(ctx, v656.0);
                                if let Some(v678) = v677 {
                                    let v679 = &C::inst_data(ctx, v678);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v680,
                                        imm: v681,
                                    } = v679
                                    {
                                        if let &Opcode::Iconst = v680 {
                                            let v682 = C::u64_from_imm64(ctx, v681);
                                            if v682 == 0x0 {
                                                let v683 = C::value_type(ctx, v656.1);
                                                match v683 {
                                                    I32 => {
                                                        let v684 =
                                                            constructor_put_in_gpr(ctx, v656.1);
                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };
                                                        let v697 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);
                                                        let v700 = constructor_x64_shr(
                                                            ctx, I32, v684, v697,
                                                        );
                                                        let v701 =
                                                            constructor_output_gpr(ctx, v700);
                                                        // Rule at src/isa/x64/lower.isle line 1430.
                                                        return Some(v701);
                                                    }
                                                    I64 => {
                                                        let v684 =
                                                            constructor_put_in_gpr(ctx, v656.1);
                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };
                                                        let v674 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);
                                                        let v685 = constructor_x64_shr(
                                                            ctx, I64, v684, v674,
                                                        );
                                                        let v686 =
                                                            constructor_output_gpr(ctx, v685);
                                                        // Rule at src/isa/x64/lower.isle line 1414.
                                                        return Some(v686);
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v717 = constructor_x64_pcmpgt(ctx, v708, v709, v710);
                            let v718 = constructor_output_xmm(ctx, v717);
                            // Rule at src/isa/x64/lower.isle line 1458.
                            return Some(v718);
                        }
                    }
                    &IntCC::SignedGreaterThanOrEqual => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        match v659 {
                            I32 => {
                                let v1 = C::first_result(ctx, arg0);
                                if let Some(v2) = v1 {
                                    let v3 = C::value_type(ctx, v2);
                                    if v3 == I8 {
                                        let v665 = C::def_inst(ctx, v656.1);
                                        if let Some(v666) = v665 {
                                            let v667 = &C::inst_data(ctx, v666);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v668,
                                                imm: v669,
                                            } = v667
                                            {
                                                if let &Opcode::Iconst = v668 {
                                                    let v670 = C::u64_from_imm64(ctx, v669);
                                                    if v670 == 0x0 {
                                                        let v671 =
                                                            constructor_put_in_gpr(ctx, v656.0);
                                                        let v691 =
                                                            constructor_x64_not(ctx, I64, v671);
                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };
                                                        let v702 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);
                                                        let v705 = constructor_x64_shr(
                                                            ctx, I32, v691, v702,
                                                        );
                                                        let v706 =
                                                            constructor_output_gpr(ctx, v705);
                                                        // Rule at src/isa/x64/lower.isle line 1438.
                                                        return Some(v706);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            I64 => {
                                let v1 = C::first_result(ctx, arg0);
                                if let Some(v2) = v1 {
                                    let v3 = C::value_type(ctx, v2);
                                    if v3 == I8 {
                                        let v665 = C::def_inst(ctx, v656.1);
                                        if let Some(v666) = v665 {
                                            let v667 = &C::inst_data(ctx, v666);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v668,
                                                imm: v669,
                                            } = v667
                                            {
                                                if let &Opcode::Iconst = v668 {
                                                    let v670 = C::u64_from_imm64(ctx, v669);
                                                    if v670 == 0x0 {
                                                        let v671 =
                                                            constructor_put_in_gpr(ctx, v656.0);
                                                        let v691 =
                                                            constructor_x64_not(ctx, I64, v671);
                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };
                                                        let v688 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);
                                                        let v692 = constructor_x64_shr(
                                                            ctx, I64, v691, v688,
                                                        );
                                                        let v693 =
                                                            constructor_output_gpr(ctx, v692);
                                                        // Rule at src/isa/x64/lower.isle line 1422.
                                                        return Some(v693);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            I64X2 => {
                                let v719 = constructor_put_in_xmm(ctx, v656.1);
                                let v720 = &C::put_in_xmm_mem(ctx, v656.0);
                                let v753 = constructor_x64_pcmpgt(ctx, I64X2, v719, v720);
                                let v713 = constructor_vector_all_ones(ctx);
                                let v714 = &C::xmm_to_xmm_mem(ctx, v713);
                                let v754 = constructor_x64_pxor(ctx, v753, v714);
                                let v755 = constructor_output_xmm(ctx, v754);
                                // Rule at src/isa/x64/lower.isle line 1498.
                                return Some(v755);
                            }
                            _ => {}
                        }
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v736 = constructor_x64_pmaxs(ctx, v708, v709, v710);
                            let v737 = constructor_put_in_xmm(ctx, v656.0);
                            let v738 = &C::xmm_to_xmm_mem(ctx, v736);
                            let v739 = constructor_x64_pcmpeq(ctx, v708, v737, v738);
                            let v740 = constructor_output_xmm(ctx, v739);
                            // Rule at src/isa/x64/lower.isle line 1483.
                            return Some(v740);
                        }
                    }
                    &IntCC::SignedLessThan => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v656 = C::unpack_value_array_2(ctx, v654);
                                let v659 = C::value_type(ctx, v656.0);
                                match v659 {
                                    I32 => {
                                        let v665 = C::def_inst(ctx, v656.1);
                                        if let Some(v666) = v665 {
                                            let v667 = &C::inst_data(ctx, v666);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v668,
                                                imm: v669,
                                            } = v667
                                            {
                                                if let &Opcode::Iconst = v668 {
                                                    let v670 = C::u64_from_imm64(ctx, v669);
                                                    if v670 == 0x0 {
                                                        let v671 =
                                                            constructor_put_in_gpr(ctx, v656.0);
                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };
                                                        let v697 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);
                                                        let v698 = constructor_x64_shr(
                                                            ctx, I32, v671, v697,
                                                        );
                                                        let v699 =
                                                            constructor_output_gpr(ctx, v698);
                                                        // Rule at src/isa/x64/lower.isle line 1426.
                                                        return Some(v699);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    I64 => {
                                        let v665 = C::def_inst(ctx, v656.1);
                                        if let Some(v666) = v665 {
                                            let v667 = &C::inst_data(ctx, v666);
                                            if let &InstructionData::UnaryImm {
                                                opcode: ref v668,
                                                imm: v669,
                                            } = v667
                                            {
                                                if let &Opcode::Iconst = v668 {
                                                    let v670 = C::u64_from_imm64(ctx, v669);
                                                    if v670 == 0x0 {
                                                        let v671 =
                                                            constructor_put_in_gpr(ctx, v656.0);
                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };
                                                        let v674 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);
                                                        let v675 = constructor_x64_shr(
                                                            ctx, I64, v671, v674,
                                                        );
                                                        let v676 =
                                                            constructor_output_gpr(ctx, v675);
                                                        // Rule at src/isa/x64/lower.isle line 1410.
                                                        return Some(v676);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v719 = constructor_put_in_xmm(ctx, v656.1);
                            let v720 = &C::put_in_xmm_mem(ctx, v656.0);
                            let v721 = constructor_x64_pcmpgt(ctx, v708, v719, v720);
                            let v722 = constructor_output_xmm(ctx, v721);
                            // Rule at src/isa/x64/lower.isle line 1460.
                            return Some(v722);
                        }
                    }
                    &IntCC::SignedLessThanOrEqual => {
                        let v1 = C::first_result(ctx, arg0);
                        if let Some(v2) = v1 {
                            let v3 = C::value_type(ctx, v2);
                            if v3 == I8 {
                                let v656 = C::unpack_value_array_2(ctx, v654);
                                let v677 = C::def_inst(ctx, v656.0);
                                if let Some(v678) = v677 {
                                    let v679 = &C::inst_data(ctx, v678);
                                    if let &InstructionData::UnaryImm {
                                        opcode: ref v680,
                                        imm: v681,
                                    } = v679
                                    {
                                        if let &Opcode::Iconst = v680 {
                                            let v682 = C::u64_from_imm64(ctx, v681);
                                            if v682 == 0x0 {
                                                let v683 = C::value_type(ctx, v656.1);
                                                match v683 {
                                                    I32 => {
                                                        let v684 =
                                                            constructor_put_in_gpr(ctx, v656.1);
                                                        let v687 =
                                                            constructor_x64_not(ctx, I64, v684);
                                                        let v696 = Imm8Reg::Imm8 { imm: 0x1F };
                                                        let v702 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v696);
                                                        let v703 = constructor_x64_shr(
                                                            ctx, I32, v687, v702,
                                                        );
                                                        let v704 =
                                                            constructor_output_gpr(ctx, v703);
                                                        // Rule at src/isa/x64/lower.isle line 1434.
                                                        return Some(v704);
                                                    }
                                                    I64 => {
                                                        let v684 =
                                                            constructor_put_in_gpr(ctx, v656.1);
                                                        let v687 =
                                                            constructor_x64_not(ctx, I64, v684);
                                                        let v673 = Imm8Reg::Imm8 { imm: 0x3F };
                                                        let v688 =
                                                            &C::imm8_reg_to_imm8_gpr(ctx, &v673);
                                                        let v689 = constructor_x64_shr(
                                                            ctx, I64, v687, v688,
                                                        );
                                                        let v690 =
                                                            constructor_output_gpr(ctx, v689);
                                                        // Rule at src/isa/x64/lower.isle line 1418.
                                                        return Some(v690);
                                                    }
                                                    _ => {}
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        if v659 == I64X2 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v756 = constructor_x64_pcmpgt(ctx, I64X2, v709, v710);
                            let v713 = constructor_vector_all_ones(ctx);
                            let v714 = &C::xmm_to_xmm_mem(ctx, v713);
                            let v757 = constructor_x64_pxor(ctx, v756, v714);
                            let v758 = constructor_output_xmm(ctx, v757);
                            // Rule at src/isa/x64/lower.isle line 1502.
                            return Some(v758);
                        }
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v741 = constructor_x64_pmins(ctx, v708, v709, v710);
                            let v737 = constructor_put_in_xmm(ctx, v656.0);
                            let v742 = &C::xmm_to_xmm_mem(ctx, v741);
                            let v743 = constructor_x64_pcmpeq(ctx, v708, v737, v742);
                            let v744 = constructor_output_xmm(ctx, v743);
                            // Rule at src/isa/x64/lower.isle line 1486.
                            return Some(v744);
                        }
                    }
                    &IntCC::UnsignedGreaterThan => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v723 = constructor_put_in_xmm(ctx, v656.1);
                            let v724 = &C::xmm_to_xmm_mem(ctx, v723);
                            let v725 = constructor_x64_pmaxu(ctx, v708, v709, v724);
                            let v726 = &C::xmm_to_xmm_mem(ctx, v723);
                            let v727 = constructor_x64_pcmpeq(ctx, v708, v725, v726);
                            let v728 = constructor_vector_all_ones(ctx);
                            let v729 = &C::xmm_to_xmm_mem(ctx, v728);
                            let v730 = constructor_x64_pxor(ctx, v727, v729);
                            let v731 = constructor_output_xmm(ctx, v730);
                            // Rule at src/isa/x64/lower.isle line 1462.
                            return Some(v731);
                        }
                    }
                    &IntCC::UnsignedGreaterThanOrEqual => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v745 = constructor_x64_pmaxu(ctx, v708, v709, v710);
                            let v737 = constructor_put_in_xmm(ctx, v656.0);
                            let v746 = &C::xmm_to_xmm_mem(ctx, v745);
                            let v747 = constructor_x64_pcmpeq(ctx, v708, v737, v746);
                            let v748 = constructor_output_xmm(ctx, v747);
                            // Rule at src/isa/x64/lower.isle line 1489.
                            return Some(v748);
                        }
                    }
                    &IntCC::UnsignedLessThan => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v723 = constructor_put_in_xmm(ctx, v656.1);
                            let v724 = &C::xmm_to_xmm_mem(ctx, v723);
                            let v732 = constructor_x64_pminu(ctx, v708, v709, v724);
                            let v726 = &C::xmm_to_xmm_mem(ctx, v723);
                            let v733 = constructor_x64_pcmpeq(ctx, v708, v732, v726);
                            let v728 = constructor_vector_all_ones(ctx);
                            let v729 = &C::xmm_to_xmm_mem(ctx, v728);
                            let v734 = constructor_x64_pxor(ctx, v733, v729);
                            let v735 = constructor_output_xmm(ctx, v734);
                            // Rule at src/isa/x64/lower.isle line 1472.
                            return Some(v735);
                        }
                    }
                    &IntCC::UnsignedLessThanOrEqual => {
                        let v656 = C::unpack_value_array_2(ctx, v654);
                        let v659 = C::value_type(ctx, v656.0);
                        let v707 = C::ty_vec128(ctx, v659);
                        if let Some(v708) = v707 {
                            let v709 = constructor_put_in_xmm(ctx, v656.0);
                            let v710 = &C::put_in_xmm_mem(ctx, v656.1);
                            let v749 = constructor_x64_pminu(ctx, v708, v709, v710);
                            let v737 = constructor_put_in_xmm(ctx, v656.0);
                            let v750 = &C::xmm_to_xmm_mem(ctx, v749);
                            let v751 = constructor_x64_pcmpeq(ctx, v708, v737, v750);
                            let v752 = constructor_output_xmm(ctx, v751);
                            // Rule at src/isa/x64/lower.isle line 1492.
                            return Some(v752);
                        }
                    }
                    _ => {}
                }
                let v656 = C::unpack_value_array_2(ctx, v654);
                let v659 = C::value_type(ctx, v656.0);
                if v659 == I128 {
                    let v662 = &constructor_emit_cmp(ctx, v655, v656.0, v656.1);
                    let v663 = constructor_lower_icmp_bool(ctx, v662);
                    let v664 = C::output(ctx, v663);
                    // Rule at src/isa/x64/lower.isle line 1406.
                    return Some(v664);
                }
                let v660 = C::fits_in_64(ctx, v659);
                if let Some(v661) = v660 {
                    let v662 = &constructor_emit_cmp(ctx, v655, v656.0, v656.1);
                    let v663 = constructor_lower_icmp_bool(ctx, v662);
                    let v664 = C::output(ctx, v663);
                    // Rule at src/isa/x64/lower.isle line 1403.
                    return Some(v664);
                }
            }
        }
        &InstructionData::Load {
            opcode: ref v1254,
            arg: v1255,
            flags: v1256,
            offset: v1257,
        } => {
            match v1254 {
                &Opcode::Load => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);
                                let v1287 = constructor_x64_movss_load(ctx, v1286);
                                let v1288 = constructor_output_xmm(ctx, v1287);
                                // Rule at src/isa/x64/lower.isle line 2425.
                                return Some(v1288);
                            }
                            F64 => {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);
                                let v1289 = constructor_x64_movsd_load(ctx, v1286);
                                let v1290 = constructor_output_xmm(ctx, v1289);
                                // Rule at src/isa/x64/lower.isle line 2427.
                                return Some(v1290);
                            }
                            F32X4 => {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);
                                let v1291 = constructor_x64_movups_load(ctx, v1286);
                                let v1292 = constructor_output_xmm(ctx, v1291);
                                // Rule at src/isa/x64/lower.isle line 2429.
                                return Some(v1292);
                            }
                            F64X2 => {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1286 = &C::amode_to_synthetic_amode(ctx, v1267);
                                let v1293 = constructor_x64_movupd_load(ctx, v1286);
                                let v1294 = constructor_output_xmm(ctx, v1293);
                                // Rule at src/isa/x64/lower.isle line 2431.
                                return Some(v1294);
                            }
                            _ => {}
                        }
                        let v1265 = C::ty_int_ref_64(ctx, v3);
                        if let Some(v1266) = v1265 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1268 = constructor_x64_mov(ctx, v1267);
                            let v1269 = constructor_output_reg(ctx, v1268);
                            // Rule at src/isa/x64/lower.isle line 2403.
                            return Some(v1269);
                        }
                        let v1295 = C::ty_vec128(ctx, v3);
                        if let Some(v1296) = v1295 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1298 = constructor_x64_movdqu_load(ctx, v1297);
                            let v1299 = constructor_output_xmm(ctx, v1298);
                            // Rule at src/isa/x64/lower.isle line 2433.
                            return Some(v1299);
                        }
                        if v3 == I128 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1301 = &C::amode_offset(ctx, v1267, 0x8);
                            let v1302 = constructor_x64_mov(ctx, v1267);
                            let v1303 = constructor_x64_mov(ctx, v1301);
                            let v1304 = C::value_regs(ctx, v1302, v1303);
                            let v1305 = C::output(ctx, v1304);
                            // Rule at src/isa/x64/lower.isle line 2437.
                            return Some(v1305);
                        }
                        let v997 = C::fits_in_32(ctx, v3);
                        if let Some(v998) = v997 {
                            let v1251 = &C::type_register_class(ctx, v3);
                            if let Some(v1252) = v1251 {
                                if let &RegisterClass::Gpr {
                                    single_register: v1253,
                                } = v1252
                                {
                                    let v1258 = C::ty_bits_u16(ctx, v998);
                                    let v1260 = &C::ext_mode(ctx, v1258, 0x40);
                                    let v1261 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                    let v1262 = &constructor_amode_to_gpr_mem(ctx, v1261);
                                    let v1263 = constructor_x64_movzx(ctx, v1260, v1262);
                                    let v1264 = constructor_output_gpr(ctx, v1263);
                                    // Rule at src/isa/x64/lower.isle line 2399.
                                    return Some(v1264);
                                }
                            }
                        }
                    }
                }
                &Opcode::Uload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1272 = constructor_x64_movzx(ctx, &ExtMode::BQ, v1271);
                                let v1273 = constructor_output_gpr(ctx, v1272);
                                // Rule at src/isa/x64/lower.isle line 2408.
                                return Some(v1273);
                            }
                        }
                    }
                }
                &Opcode::Sload8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1274 = constructor_x64_movsx(ctx, &ExtMode::BQ, v1271);
                                let v1275 = constructor_output_gpr(ctx, v1274);
                                // Rule at src/isa/x64/lower.isle line 2410.
                                return Some(v1275);
                            }
                        }
                    }
                }
                &Opcode::Uload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1277 = constructor_x64_movzx(ctx, &ExtMode::WQ, v1271);
                                let v1278 = constructor_output_gpr(ctx, v1277);
                                // Rule at src/isa/x64/lower.isle line 2412.
                                return Some(v1278);
                            }
                        }
                    }
                }
                &Opcode::Sload16 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1279 = constructor_x64_movsx(ctx, &ExtMode::WQ, v1271);
                                let v1280 = constructor_output_gpr(ctx, v1279);
                                // Rule at src/isa/x64/lower.isle line 2414.
                                return Some(v1280);
                            }
                        }
                    }
                }
                &Opcode::Uload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1282 = constructor_x64_movzx(ctx, &ExtMode::LQ, v1271);
                                let v1283 = constructor_output_gpr(ctx, v1282);
                                // Rule at src/isa/x64/lower.isle line 2416.
                                return Some(v1283);
                            }
                        }
                    }
                }
                &Opcode::Sload32 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            if let &RegisterClass::Gpr {
                                single_register: v1253,
                            } = v1252
                            {
                                let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                                let v1271 = &constructor_amode_to_gpr_mem(ctx, v1267);
                                let v1284 = constructor_x64_movsx(ctx, &ExtMode::LQ, v1271);
                                let v1285 = constructor_output_gpr(ctx, v1284);
                                // Rule at src/isa/x64/lower.isle line 2418.
                                return Some(v1285);
                            }
                        }
                    }
                }
                &Opcode::Uload8x8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1308 = constructor_x64_pmovzxbw(ctx, v1297);
                            let v1309 = constructor_output_xmm(ctx, v1308);
                            // Rule at src/isa/x64/lower.isle line 2449.
                            return Some(v1309);
                        }
                    }
                }
                &Opcode::Sload8x8 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I16X8 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1306 = constructor_x64_pmovsxbw(ctx, v1297);
                            let v1307 = constructor_output_xmm(ctx, v1306);
                            // Rule at src/isa/x64/lower.isle line 2447.
                            return Some(v1307);
                        }
                    }
                }
                &Opcode::Uload16x4 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1312 = constructor_x64_pmovzxwd(ctx, v1297);
                            let v1313 = constructor_output_xmm(ctx, v1312);
                            // Rule at src/isa/x64/lower.isle line 2453.
                            return Some(v1313);
                        }
                    }
                }
                &Opcode::Sload16x4 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1310 = constructor_x64_pmovsxwd(ctx, v1297);
                            let v1311 = constructor_output_xmm(ctx, v1310);
                            // Rule at src/isa/x64/lower.isle line 2451.
                            return Some(v1311);
                        }
                    }
                }
                &Opcode::Uload32x2 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I64X2 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1316 = constructor_x64_pmovzxdq(ctx, v1297);
                            let v1317 = constructor_output_xmm(ctx, v1316);
                            // Rule at src/isa/x64/lower.isle line 2457.
                            return Some(v1317);
                        }
                    }
                }
                &Opcode::Sload32x2 => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I64X2 {
                            let v1267 = &constructor_to_amode(ctx, v1256, v1255, v1257);
                            let v1297 = &constructor_amode_to_xmm_mem(ctx, v1267);
                            let v1314 = constructor_x64_pmovsxdq(ctx, v1297);
                            let v1315 = constructor_output_xmm(ctx, v1314);
                            // Rule at src/isa/x64/lower.isle line 2455.
                            return Some(v1315);
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::LoadNoOffset {
            opcode: ref v1457,
            arg: v1458,
            flags: v1459,
        } => {
            match v1457 {
                &Opcode::Bitcast => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v1251 = &C::type_register_class(ctx, v3);
                        if let Some(v1252) = v1251 {
                            match v1252 {
                                &RegisterClass::Gpr {
                                    single_register: v1253,
                                } => {
                                    let v1783 = C::value_type(ctx, v1458);
                                    let v1794 = &C::type_register_class(ctx, v1783);
                                    if let Some(v1795) = v1794 {
                                        if let &RegisterClass::Gpr {
                                            single_register: v1796,
                                        } = v1795
                                        {
                                            let v1797 = constructor_output_value(ctx, v1458);
                                            // Rule at src/isa/x64/lower.isle line 3266.
                                            return Some(v1797);
                                        }
                                    }
                                }
                                &RegisterClass::Xmm => {
                                    let v1783 = C::value_type(ctx, v1458);
                                    let v1794 = &C::type_register_class(ctx, v1783);
                                    if let Some(v1795) = v1794 {
                                        if let &RegisterClass::Xmm = v1795 {
                                            let v1797 = constructor_output_value(ctx, v1458);
                                            // Rule at src/isa/x64/lower.isle line 3270.
                                            return Some(v1797);
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        match v3 {
                            I32 => {
                                let v1783 = C::value_type(ctx, v1458);
                                if v1783 == F32 {
                                    let v1784 = constructor_put_in_xmm(ctx, v1458);
                                    let v1785 = constructor_bitcast_xmm_to_gpr(ctx, F32, v1784);
                                    let v1786 = constructor_output_gpr(ctx, v1785);
                                    // Rule at src/isa/x64/lower.isle line 3253.
                                    return Some(v1786);
                                }
                            }
                            I64 => {
                                let v1783 = C::value_type(ctx, v1458);
                                if v1783 == F64 {
                                    let v1784 = constructor_put_in_xmm(ctx, v1458);
                                    let v1790 = constructor_bitcast_xmm_to_gpr(ctx, F64, v1784);
                                    let v1791 = constructor_output_gpr(ctx, v1790);
                                    // Rule at src/isa/x64/lower.isle line 3259.
                                    return Some(v1791);
                                }
                            }
                            F32 => {
                                let v1783 = C::value_type(ctx, v1458);
                                if v1783 == I32 {
                                    let v1787 = constructor_put_in_gpr(ctx, v1458);
                                    let v1788 = constructor_bitcast_gpr_to_xmm(ctx, I32, v1787);
                                    let v1789 = constructor_output_xmm(ctx, v1788);
                                    // Rule at src/isa/x64/lower.isle line 3256.
                                    return Some(v1789);
                                }
                            }
                            F64 => {
                                let v1783 = C::value_type(ctx, v1458);
                                if v1783 == I64 {
                                    let v1787 = constructor_put_in_gpr(ctx, v1458);
                                    let v1792 = constructor_bitcast_gpr_to_xmm(ctx, I64, v1787);
                                    let v1793 = constructor_output_xmm(ctx, v1792);
                                    // Rule at src/isa/x64/lower.isle line 3262.
                                    return Some(v1793);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::AtomicLoad => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I64 {
                            let v48 = C::zero_offset(ctx);
                            let v1460 = &constructor_to_amode(ctx, v1459, v1458, v48);
                            let v1461 = constructor_x64_mov(ctx, v1460);
                            let v1462 = constructor_output_reg(ctx, v1461);
                            // Rule at src/isa/x64/lower.isle line 2730.
                            return Some(v1462);
                        }
                        let v997 = C::fits_in_32(ctx, v3);
                        if let Some(v998) = v997 {
                            let v1463 = C::ty_int(ctx, v3);
                            if let Some(v1464) = v1463 {
                                let v1258 = C::ty_bits_u16(ctx, v998);
                                let v1260 = &C::ext_mode(ctx, v1258, 0x40);
                                let v1465 = C::zero_offset(ctx);
                                let v1466 = &constructor_to_amode(ctx, v1459, v1458, v1465);
                                let v1467 = &constructor_amode_to_gpr_mem(ctx, v1466);
                                let v1468 = constructor_x64_movzx(ctx, v1260, v1467);
                                let v1469 = constructor_output_gpr(ctx, v1468);
                                // Rule at src/isa/x64/lower.isle line 2732.
                                return Some(v1469);
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::MultiAry {
            opcode: ref v647,
            args: v648,
        } => {
            if let &Opcode::Return = v647 {
                let v649 = C::value_list_slice(ctx, v648);
                let v650 = C::value_slice_len(ctx, v649);
                let v651 = C::range(ctx, 0x0, v650);
                let v652 = constructor_lower_return(ctx, v651, v649);
                // Rule at src/isa/x64/lower.isle line 1398.
                return Some(v652);
            }
        }
        &InstructionData::NullAry { opcode: ref v31 } => {
            match v31 {
                &Opcode::Debugtrap => {
                    let v1011 = &constructor_x64_hlt(ctx);
                    let v1012 = constructor_side_effect(ctx, v1011);
                    // Rule at src/isa/x64/lower.isle line 2020.
                    return Some(v1012);
                }
                &Opcode::GetPinnedReg => {
                    let v1958 = constructor_read_pinned_gpr(ctx);
                    let v1959 = constructor_output_gpr(ctx, v1958);
                    // Rule at src/isa/x64/lower.isle line 3538.
                    return Some(v1959);
                }
                &Opcode::GetFramePointer => {
                    let v1533 = constructor_x64_rbp(ctx);
                    let v1534 = constructor_output_reg(ctx, v1533);
                    // Rule at src/isa/x64/lower.isle line 2779.
                    return Some(v1534);
                }
                &Opcode::GetStackPointer => {
                    let v1535 = constructor_x64_rsp(ctx);
                    let v1536 = constructor_output_reg(ctx, v1535);
                    // Rule at src/isa/x64/lower.isle line 2782.
                    return Some(v1536);
                }
                &Opcode::GetReturnAddress => {
                    let v1533 = constructor_x64_rbp(ctx);
                    let v47 = C::mem_flags_trusted(ctx);
                    let v1537 = Amode::ImmReg {
                        simm32: 0x8,
                        base: v1533,
                        flags: v47,
                    };
                    let v1538 = &C::amode_to_synthetic_amode(ctx, &v1537);
                    let v1539 = constructor_x64_load(ctx, I64, v1538, &ExtKind::None);
                    let v1540 = constructor_output_reg(ctx, v1539);
                    // Rule at src/isa/x64/lower.isle line 2785.
                    return Some(v1540);
                }
                &Opcode::Null => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v32 = constructor_imm(ctx, v3, 0x0);
                        let v33 = constructor_output_reg(ctx, v32);
                        // Rule at src/isa/x64/lower.isle line 37.
                        return Some(v33);
                    }
                }
                &Opcode::Nop => {
                    let v2247 = C::invalid_reg(ctx);
                    let v2248 = constructor_output_reg(ctx, v2247);
                    // Rule at src/isa/x64/lower.isle line 3983.
                    return Some(v2248);
                }
                &Opcode::Fence => {
                    let v1437 = &constructor_x64_mfence(ctx);
                    let v1438 = constructor_side_effect(ctx, v1437);
                    // Rule at src/isa/x64/lower.isle line 2708.
                    return Some(v1438);
                }
                _ => {}
            }
        }
        &InstructionData::Shuffle {
            opcode: ref v1967,
            args: ref v1968,
            imm: v1969,
        } => {
            if let &Opcode::Shuffle = v1967 {
                let v1973 = C::pblendw_imm(ctx, v1969);
                if let Some(v1974) = v1973 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                    let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                    let v1977 = constructor_x64_pblendw(ctx, v1975, v1976, v1974);
                    let v1978 = constructor_output_xmm(ctx, v1977);
                    // Rule at src/isa/x64/lower.isle line 3558.
                    return Some(v1978);
                }
                let v1979 = C::palignr_imm_from_immediate(ctx, v1969);
                if let Some(v1980) = v1979 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);
                    let v1982 = &C::put_in_xmm_mem(ctx, v1970.0);
                    let v1983 = constructor_x64_palignr(ctx, v1981, v1982, v1980);
                    let v1984 = constructor_output_xmm(ctx, v1983);
                    // Rule at src/isa/x64/lower.isle line 3568.
                    return Some(v1984);
                }
                let v1985 = C::pshuflw_lhs_imm(ctx, v1969);
                if let Some(v1986) = v1985 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);
                    let v1988 = constructor_x64_pshuflw(ctx, v1987, v1986);
                    let v1989 = constructor_output_xmm(ctx, v1988);
                    // Rule at src/isa/x64/lower.isle line 3579.
                    return Some(v1989);
                }
                let v1990 = C::pshuflw_rhs_imm(ctx, v1969);
                if let Some(v1991) = v1990 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);
                    let v1993 = constructor_x64_pshuflw(ctx, v1992, v1991);
                    let v1994 = constructor_output_xmm(ctx, v1993);
                    // Rule at src/isa/x64/lower.isle line 3581.
                    return Some(v1994);
                }
                let v1995 = C::pshufhw_lhs_imm(ctx, v1969);
                if let Some(v1996) = v1995 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);
                    let v1997 = constructor_x64_pshufhw(ctx, v1987, v1996);
                    let v1998 = constructor_output_xmm(ctx, v1997);
                    // Rule at src/isa/x64/lower.isle line 3583.
                    return Some(v1998);
                }
                let v1999 = C::pshufhw_rhs_imm(ctx, v1969);
                if let Some(v2000) = v1999 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);
                    let v2001 = constructor_x64_pshufhw(ctx, v1992, v2000);
                    let v2002 = constructor_output_xmm(ctx, v2001);
                    // Rule at src/isa/x64/lower.isle line 3585.
                    return Some(v2002);
                }
                let v2003 = C::pshufd_lhs_imm(ctx, v1969);
                if let Some(v2004) = v2003 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1987 = &C::put_in_xmm_mem(ctx, v1970.0);
                    let v2005 = constructor_x64_pshufd(ctx, v1987, v2004);
                    let v2006 = constructor_output_xmm(ctx, v2005);
                    // Rule at src/isa/x64/lower.isle line 3602.
                    return Some(v2006);
                }
                let v2007 = C::pshufd_rhs_imm(ctx, v1969);
                if let Some(v2008) = v2007 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1992 = &C::put_in_xmm_mem(ctx, v1970.1);
                    let v2009 = constructor_x64_pshufd(ctx, v1992, v2008);
                    let v2010 = constructor_output_xmm(ctx, v2009);
                    // Rule at src/isa/x64/lower.isle line 3604.
                    return Some(v2010);
                }
                let v2011 = C::u128_from_immediate(ctx, v1969);
                if let Some(v2012) = v2011 {
                    match v2012 {
                        0x0 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v2029 = constructor_xmm_zero(ctx, I8X16);
                            let v2030 = &C::xmm_to_xmm_mem(ctx, v2029);
                            let v2031 = constructor_x64_pshufb(ctx, v1975, v2030);
                            let v2032 = constructor_output_xmm(ctx, v2031);
                            // Rule at src/isa/x64/lower.isle line 3641.
                            return Some(v2032);
                        }
                        0x17071606150514041303120211011000 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2015 = constructor_x64_punpcklbw(ctx, v1975, v1976);
                            let v2016 = constructor_output_xmm(ctx, v2015);
                            // Rule at src/isa/x64/lower.isle line 3615.
                            return Some(v2016);
                        }
                        0x17160706151405041312030211100100 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2019 = constructor_x64_punpcklwd(ctx, v1975, v1976);
                            let v2020 = constructor_output_xmm(ctx, v2019);
                            // Rule at src/isa/x64/lower.isle line 3621.
                            return Some(v2020);
                        }
                        0x17161514070605041312111003020100 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2023 = constructor_x64_punpckldq(ctx, v1975, v1976);
                            let v2024 = constructor_output_xmm(ctx, v2023);
                            // Rule at src/isa/x64/lower.isle line 3627.
                            return Some(v2024);
                        }
                        0x17161514131211100706050403020100 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2027 = constructor_x64_punpcklqdq(ctx, v1975, v1976);
                            let v2028 = constructor_output_xmm(ctx, v2027);
                            // Rule at src/isa/x64/lower.isle line 3633.
                            return Some(v2028);
                        }
                        0x1F0F1E0E1D0D1C0C1B0B1A0A19091808 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2013 = constructor_x64_punpckhbw(ctx, v1975, v1976);
                            let v2014 = constructor_output_xmm(ctx, v2013);
                            // Rule at src/isa/x64/lower.isle line 3613.
                            return Some(v2014);
                        }
                        0x1F1E0F0E1D1C0D0C1B1A0B0A19180908 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2017 = constructor_x64_punpckhwd(ctx, v1975, v1976);
                            let v2018 = constructor_output_xmm(ctx, v2017);
                            // Rule at src/isa/x64/lower.isle line 3619.
                            return Some(v2018);
                        }
                        0x1F1E1D1C0F0E0D0C1B1A19180B0A0908 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2021 = constructor_x64_punpckhdq(ctx, v1975, v1976);
                            let v2022 = constructor_output_xmm(ctx, v2021);
                            // Rule at src/isa/x64/lower.isle line 3625.
                            return Some(v2022);
                        }
                        0x1F1E1D1C1B1A19180F0E0D0C0B0A0908 => {
                            let v1970 = C::unpack_value_array_2(ctx, v1968);
                            let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                            let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                            let v2025 = constructor_x64_punpckhqdq(ctx, v1975, v1976);
                            let v2026 = constructor_output_xmm(ctx, v2025);
                            // Rule at src/isa/x64/lower.isle line 3631.
                            return Some(v2026);
                        }
                        _ => {}
                    }
                }
                let v2033 = C::shufps_imm(ctx, v1969);
                if let Some(v2034) = v2033 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                    let v1976 = &C::put_in_xmm_mem(ctx, v1970.1);
                    let v2035 = constructor_x64_shufps(ctx, v1975, v1976, v2034);
                    let v2036 = constructor_output_xmm(ctx, v2035);
                    // Rule at src/isa/x64/lower.isle line 3654.
                    return Some(v2036);
                }
                let v2037 = C::shufps_rev_imm(ctx, v1969);
                if let Some(v2038) = v2037 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);
                    let v1982 = &C::put_in_xmm_mem(ctx, v1970.0);
                    let v2039 = constructor_x64_shufps(ctx, v1981, v1982, v2038);
                    let v2040 = constructor_output_xmm(ctx, v2039);
                    // Rule at src/isa/x64/lower.isle line 3656.
                    return Some(v2040);
                }
                let v2041 = &C::vec_mask_from_immediate(ctx, v1969);
                if let Some(v2042) = v2041 {
                    let v1970 = C::unpack_value_array_2(ctx, v1968);
                    if v1970.0 == v1970.1 {
                        let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                        let v2043 = C::shuffle_0_31_mask(ctx, v2042);
                        let v2044 = &constructor_const_to_xmm_mem(ctx, v2043);
                        let v2045 = constructor_x64_pshufb(ctx, v1975, v2044);
                        let v2046 = constructor_output_xmm(ctx, v2045);
                        // Rule at src/isa/x64/lower.isle line 3669.
                        return Some(v2046);
                    }
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v363 = C::avx512vl_enabled(ctx, v3);
                        if v363 == true {
                            let v2047 = C::avx512vbmi_enabled(ctx, v3);
                            if v2047 == true {
                                let v2048 = C::perm_from_mask_with_zeros(ctx, v2042);
                                if let Some(v2049) = v2048 {
                                    let v1981 = constructor_put_in_xmm(ctx, v1970.1);
                                    let v2052 = constructor_put_in_xmm(ctx, v1970.0);
                                    let v2053 = constructor_x64_xmm_load_const(ctx, I8X16, v2049.0);
                                    let v2054 = constructor_x64_vpermi2b(ctx, v1981, v2052, v2053);
                                    let v2055 = &constructor_const_to_xmm_mem(ctx, v2049.1);
                                    let v2056 = constructor_x64_andps(ctx, v2054, v2055);
                                    let v2057 = constructor_output_xmm(ctx, v2056);
                                    // Rule at src/isa/x64/lower.isle line 3675.
                                    return Some(v2057);
                                }
                                let v1981 = constructor_put_in_xmm(ctx, v1970.1);
                                let v2052 = constructor_put_in_xmm(ctx, v1970.0);
                                let v2058 = C::perm_from_mask(ctx, v2042);
                                let v2059 = constructor_x64_xmm_load_const(ctx, I8X16, v2058);
                                let v2060 = constructor_x64_vpermi2b(ctx, v1981, v2052, v2059);
                                let v2061 = constructor_output_xmm(ctx, v2060);
                                // Rule at src/isa/x64/lower.isle line 3682.
                                return Some(v2061);
                            }
                        }
                    }
                    let v1975 = constructor_put_in_xmm(ctx, v1970.0);
                    let v2062 = C::shuffle_0_15_mask(ctx, v2042);
                    let v2063 = &constructor_const_to_xmm_mem(ctx, v2062);
                    let v2064 = constructor_x64_pshufb(ctx, v1975, v2063);
                    let v2065 = constructor_put_in_xmm(ctx, v1970.1);
                    let v2066 = C::shuffle_16_31_mask(ctx, v2042);
                    let v2067 = &constructor_const_to_xmm_mem(ctx, v2066);
                    let v2068 = constructor_x64_pshufb(ctx, v2065, v2067);
                    let v2069 = &C::xmm_to_xmm_mem(ctx, v2068);
                    let v2070 = constructor_x64_por(ctx, v2064, v2069);
                    let v2071 = constructor_output_xmm(ctx, v2070);
                    // Rule at src/isa/x64/lower.isle line 3689.
                    return Some(v2071);
                }
            }
        }
        &InstructionData::StackLoad {
            opcode: ref v1876,
            stack_slot: v1877,
            offset: v1878,
        } => {
            if let &Opcode::StackAddr = v1876 {
                let v1879 = constructor_stack_addr_impl(ctx, v1877, v1878);
                let v1880 = constructor_output_gpr(ctx, v1879);
                // Rule at src/isa/x64/lower.isle line 3369.
                return Some(v1880);
            }
        }
        &InstructionData::Store {
            opcode: ref v1318,
            args: ref v1319,
            flags: v1320,
            offset: v1321,
        } => {
            match v1318 {
                &Opcode::Store => {
                    let v1322 = C::unpack_value_array_2(ctx, v1319);
                    let v1365 = C::def_inst(ctx, v1322.0);
                    if let Some(v1366) = v1365 {
                        let v1367 = C::first_result(ctx, v1366);
                        if let Some(v1368) = v1367 {
                            let v1370 = &C::inst_data(ctx, v1366);
                            match v1370 {
                                &InstructionData::Binary {
                                    opcode: ref v1390,
                                    args: ref v1391,
                                } => {
                                    match v1390 {
                                        &Opcode::Iadd => {
                                            let v1369 = C::value_type(ctx, v1368);
                                            let v1388 = C::ty_32_or_64(ctx, v1369);
                                            if let Some(v1389) = v1388 {
                                                let v1392 = C::unpack_value_array_2(ctx, v1391);
                                                let v1395 = &C::sinkable_load(ctx, v1392.0);
                                                if let Some(v1396) = v1395 {
                                                    let v1397 = C::def_inst(ctx, v1392.0);
                                                    if let Some(v1398) = v1397 {
                                                        let v1399 = &C::inst_data(ctx, v1398);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1400,
                                                            arg: v1401,
                                                            flags: v1402,
                                                            offset: v1403,
                                                        } = v1399
                                                        {
                                                            if let &Opcode::Load = v1400 {
                                                                if v1320 == v1402 {
                                                                    if v1321 == v1403 {
                                                                        if v1322.1 == v1401 {
                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);
                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);
                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);
                                                                            let v1407 = &constructor_x64_add_mem(ctx, v1389, v1405, v1406);
                                                                            let v1408 = constructor_side_effect(ctx, v1407);
                                                                            // Rule at src/isa/x64/lower.isle line 2581.
                                                                            return Some(v1408);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1409 = &C::sinkable_load(ctx, v1392.1);
                                                if let Some(v1410) = v1409 {
                                                    let v1411 = C::def_inst(ctx, v1392.1);
                                                    if let Some(v1412) = v1411 {
                                                        let v1413 = &C::inst_data(ctx, v1412);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1414,
                                                            arg: v1415,
                                                            flags: v1416,
                                                            offset: v1417,
                                                        } = v1413
                                                        {
                                                            if let &Opcode::Load = v1414 {
                                                                if v1320 == v1416 {
                                                                    if v1321 == v1417 {
                                                                        if v1322.1 == v1415 {
                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);
                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);
                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);
                                                                            let v1421 = &constructor_x64_add_mem(ctx, v1389, v1419, v1420);
                                                                            let v1422 = constructor_side_effect(ctx, v1421);
                                                                            // Rule at src/isa/x64/lower.isle line 2595.
                                                                            return Some(v1422);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Isub => {
                                            let v1369 = C::value_type(ctx, v1368);
                                            let v1388 = C::ty_32_or_64(ctx, v1369);
                                            if let Some(v1389) = v1388 {
                                                let v1392 = C::unpack_value_array_2(ctx, v1391);
                                                let v1395 = &C::sinkable_load(ctx, v1392.0);
                                                if let Some(v1396) = v1395 {
                                                    let v1397 = C::def_inst(ctx, v1392.0);
                                                    if let Some(v1398) = v1397 {
                                                        let v1399 = &C::inst_data(ctx, v1398);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1400,
                                                            arg: v1401,
                                                            flags: v1402,
                                                            offset: v1403,
                                                        } = v1399
                                                        {
                                                            if let &Opcode::Load = v1400 {
                                                                if v1320 == v1402 {
                                                                    if v1321 == v1403 {
                                                                        if v1322.1 == v1401 {
                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);
                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);
                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);
                                                                            let v1423 = &constructor_x64_sub_mem(ctx, v1389, v1405, v1406);
                                                                            let v1424 = constructor_side_effect(ctx, v1423);
                                                                            // Rule at src/isa/x64/lower.isle line 2609.
                                                                            return Some(v1424);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Band => {
                                            let v1369 = C::value_type(ctx, v1368);
                                            let v1388 = C::ty_32_or_64(ctx, v1369);
                                            if let Some(v1389) = v1388 {
                                                let v1392 = C::unpack_value_array_2(ctx, v1391);
                                                let v1395 = &C::sinkable_load(ctx, v1392.0);
                                                if let Some(v1396) = v1395 {
                                                    let v1397 = C::def_inst(ctx, v1392.0);
                                                    if let Some(v1398) = v1397 {
                                                        let v1399 = &C::inst_data(ctx, v1398);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1400,
                                                            arg: v1401,
                                                            flags: v1402,
                                                            offset: v1403,
                                                        } = v1399
                                                        {
                                                            if let &Opcode::Load = v1400 {
                                                                if v1320 == v1402 {
                                                                    if v1321 == v1403 {
                                                                        if v1322.1 == v1401 {
                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);
                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);
                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);
                                                                            let v1425 = &constructor_x64_and_mem(ctx, v1389, v1405, v1406);
                                                                            let v1426 = constructor_side_effect(ctx, v1425);
                                                                            // Rule at src/isa/x64/lower.isle line 2623.
                                                                            return Some(v1426);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1409 = &C::sinkable_load(ctx, v1392.1);
                                                if let Some(v1410) = v1409 {
                                                    let v1411 = C::def_inst(ctx, v1392.1);
                                                    if let Some(v1412) = v1411 {
                                                        let v1413 = &C::inst_data(ctx, v1412);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1414,
                                                            arg: v1415,
                                                            flags: v1416,
                                                            offset: v1417,
                                                        } = v1413
                                                        {
                                                            if let &Opcode::Load = v1414 {
                                                                if v1320 == v1416 {
                                                                    if v1321 == v1417 {
                                                                        if v1322.1 == v1415 {
                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);
                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);
                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);
                                                                            let v1427 = &constructor_x64_and_mem(ctx, v1389, v1419, v1420);
                                                                            let v1428 = constructor_side_effect(ctx, v1427);
                                                                            // Rule at src/isa/x64/lower.isle line 2637.
                                                                            return Some(v1428);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bor => {
                                            let v1369 = C::value_type(ctx, v1368);
                                            let v1388 = C::ty_32_or_64(ctx, v1369);
                                            if let Some(v1389) = v1388 {
                                                let v1392 = C::unpack_value_array_2(ctx, v1391);
                                                let v1395 = &C::sinkable_load(ctx, v1392.0);
                                                if let Some(v1396) = v1395 {
                                                    let v1397 = C::def_inst(ctx, v1392.0);
                                                    if let Some(v1398) = v1397 {
                                                        let v1399 = &C::inst_data(ctx, v1398);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1400,
                                                            arg: v1401,
                                                            flags: v1402,
                                                            offset: v1403,
                                                        } = v1399
                                                        {
                                                            if let &Opcode::Load = v1400 {
                                                                if v1320 == v1402 {
                                                                    if v1321 == v1403 {
                                                                        if v1322.1 == v1401 {
                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);
                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);
                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);
                                                                            let v1429 = &constructor_x64_or_mem(ctx, v1389, v1405, v1406);
                                                                            let v1430 = constructor_side_effect(ctx, v1429);
                                                                            // Rule at src/isa/x64/lower.isle line 2651.
                                                                            return Some(v1430);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1409 = &C::sinkable_load(ctx, v1392.1);
                                                if let Some(v1410) = v1409 {
                                                    let v1411 = C::def_inst(ctx, v1392.1);
                                                    if let Some(v1412) = v1411 {
                                                        let v1413 = &C::inst_data(ctx, v1412);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1414,
                                                            arg: v1415,
                                                            flags: v1416,
                                                            offset: v1417,
                                                        } = v1413
                                                        {
                                                            if let &Opcode::Load = v1414 {
                                                                if v1320 == v1416 {
                                                                    if v1321 == v1417 {
                                                                        if v1322.1 == v1415 {
                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);
                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);
                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);
                                                                            let v1431 = &constructor_x64_or_mem(ctx, v1389, v1419, v1420);
                                                                            let v1432 = constructor_side_effect(ctx, v1431);
                                                                            // Rule at src/isa/x64/lower.isle line 2665.
                                                                            return Some(v1432);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        &Opcode::Bxor => {
                                            let v1369 = C::value_type(ctx, v1368);
                                            let v1388 = C::ty_32_or_64(ctx, v1369);
                                            if let Some(v1389) = v1388 {
                                                let v1392 = C::unpack_value_array_2(ctx, v1391);
                                                let v1395 = &C::sinkable_load(ctx, v1392.0);
                                                if let Some(v1396) = v1395 {
                                                    let v1397 = C::def_inst(ctx, v1392.0);
                                                    if let Some(v1398) = v1397 {
                                                        let v1399 = &C::inst_data(ctx, v1398);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1400,
                                                            arg: v1401,
                                                            flags: v1402,
                                                            offset: v1403,
                                                        } = v1399
                                                        {
                                                            if let &Opcode::Load = v1400 {
                                                                if v1320 == v1402 {
                                                                    if v1321 == v1403 {
                                                                        if v1322.1 == v1401 {
                                                                            let v1404 = &constructor_sink_load_to_reg_mem_imm(ctx, v1396);
                                                                            let v1405 = &constructor_to_amode(ctx, v1402, v1401, v1403);
                                                                            let v1406 = constructor_put_in_gpr(ctx, v1392.1);
                                                                            let v1433 = &constructor_x64_xor_mem(ctx, v1389, v1405, v1406);
                                                                            let v1434 = constructor_side_effect(ctx, v1433);
                                                                            // Rule at src/isa/x64/lower.isle line 2679.
                                                                            return Some(v1434);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                let v1409 = &C::sinkable_load(ctx, v1392.1);
                                                if let Some(v1410) = v1409 {
                                                    let v1411 = C::def_inst(ctx, v1392.1);
                                                    if let Some(v1412) = v1411 {
                                                        let v1413 = &C::inst_data(ctx, v1412);
                                                        if let &InstructionData::Load {
                                                            opcode: ref v1414,
                                                            arg: v1415,
                                                            flags: v1416,
                                                            offset: v1417,
                                                        } = v1413
                                                        {
                                                            if let &Opcode::Load = v1414 {
                                                                if v1320 == v1416 {
                                                                    if v1321 == v1417 {
                                                                        if v1322.1 == v1415 {
                                                                            let v1418 = &constructor_sink_load_to_reg_mem_imm(ctx, v1410);
                                                                            let v1419 = &constructor_to_amode(ctx, v1416, v1415, v1417);
                                                                            let v1420 = constructor_put_in_gpr(ctx, v1392.0);
                                                                            let v1435 = &constructor_x64_xor_mem(ctx, v1389, v1419, v1420);
                                                                            let v1436 = constructor_side_effect(ctx, v1435);
                                                                            // Rule at src/isa/x64/lower.isle line 2693.
                                                                            return Some(v1436);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                        _ => {}
                                    }
                                }
                                &InstructionData::BinaryImm8 {
                                    opcode: ref v1371,
                                    arg: v1372,
                                    imm: v1373,
                                } => {
                                    if let &Opcode::Extractlane = v1371 {
                                        let v1369 = C::value_type(ctx, v1368);
                                        match v1369 {
                                            I8 => {
                                                let v1329 = &constructor_to_amode(
                                                    ctx, v1320, v1322.1, v1321,
                                                );
                                                let v1330 =
                                                    &C::amode_to_synthetic_amode(ctx, v1329);
                                                let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                let v1380 = &constructor_x64_pextrb_store(
                                                    ctx, v1330, v1375, v1374,
                                                );
                                                let v1381 = constructor_side_effect(ctx, v1380);
                                                // Rule at src/isa/x64/lower.isle line 2553.
                                                return Some(v1381);
                                            }
                                            I16 => {
                                                let v1329 = &constructor_to_amode(
                                                    ctx, v1320, v1322.1, v1321,
                                                );
                                                let v1330 =
                                                    &C::amode_to_synthetic_amode(ctx, v1329);
                                                let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                let v1382 = &constructor_x64_pextrw_store(
                                                    ctx, v1330, v1375, v1374,
                                                );
                                                let v1383 = constructor_side_effect(ctx, v1382);
                                                // Rule at src/isa/x64/lower.isle line 2559.
                                                return Some(v1383);
                                            }
                                            I32 => {
                                                let v1329 = &constructor_to_amode(
                                                    ctx, v1320, v1322.1, v1321,
                                                );
                                                let v1330 =
                                                    &C::amode_to_synthetic_amode(ctx, v1329);
                                                let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                let v1384 = &constructor_x64_pextrd_store(
                                                    ctx, v1330, v1375, v1374,
                                                );
                                                let v1385 = constructor_side_effect(ctx, v1384);
                                                // Rule at src/isa/x64/lower.isle line 2565.
                                                return Some(v1385);
                                            }
                                            I64 => {
                                                let v1329 = &constructor_to_amode(
                                                    ctx, v1320, v1322.1, v1321,
                                                );
                                                let v1330 =
                                                    &C::amode_to_synthetic_amode(ctx, v1329);
                                                let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                let v1386 = &constructor_x64_pextrq_store(
                                                    ctx, v1330, v1375, v1374,
                                                );
                                                let v1387 = constructor_side_effect(ctx, v1386);
                                                // Rule at src/isa/x64/lower.isle line 2571.
                                                return Some(v1387);
                                            }
                                            F32 => {
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                if v1374 == 0x0 {
                                                    let v1329 = &constructor_to_amode(
                                                        ctx, v1320, v1322.1, v1321,
                                                    );
                                                    let v1330 =
                                                        &C::amode_to_synthetic_amode(ctx, v1329);
                                                    let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                    let v1376 = &constructor_x64_movss_store(
                                                        ctx, v1330, v1375,
                                                    );
                                                    let v1377 = constructor_side_effect(ctx, v1376);
                                                    // Rule at src/isa/x64/lower.isle line 2541.
                                                    return Some(v1377);
                                                }
                                            }
                                            F64 => {
                                                let v1374 = C::u8_from_uimm8(ctx, v1373);
                                                if v1374 == 0x0 {
                                                    let v1329 = &constructor_to_amode(
                                                        ctx, v1320, v1322.1, v1321,
                                                    );
                                                    let v1330 =
                                                        &C::amode_to_synthetic_amode(ctx, v1329);
                                                    let v1375 = constructor_put_in_xmm(ctx, v1372);
                                                    let v1378 = &constructor_x64_movsd_store(
                                                        ctx, v1330, v1375,
                                                    );
                                                    let v1379 = constructor_side_effect(ctx, v1378);
                                                    // Rule at src/isa/x64/lower.isle line 2547.
                                                    return Some(v1379);
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    let v1325 = C::value_type(ctx, v1322.0);
                    match v1325 {
                        I128 => {
                            let v1354 = C::put_in_regs(ctx, v1322.0);
                            let v1355 = constructor_value_regs_get_gpr(ctx, v1354, 0x0);
                            let v1356 = constructor_value_regs_get_gpr(ctx, v1354, 0x1);
                            let v1357 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1358 = &C::amode_offset(ctx, v1357, 0x8);
                            let v1359 = &C::amode_to_synthetic_amode(ctx, v1357);
                            let v1360 = &constructor_x64_movrm(ctx, I64, v1359, v1355);
                            let v1361 = &C::amode_to_synthetic_amode(ctx, v1358);
                            let v1362 = &constructor_x64_movrm(ctx, I64, v1361, v1356);
                            let v1363 = &constructor_side_effect_concat(ctx, v1360, v1362);
                            let v1364 = constructor_side_effect(ctx, v1363);
                            // Rule at src/isa/x64/lower.isle line 2522.
                            return Some(v1364);
                        }
                        F32 => {
                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);
                            let v1342 = &constructor_x64_movss_store(ctx, v1330, v1341);
                            let v1343 = constructor_side_effect(ctx, v1342);
                            // Rule at src/isa/x64/lower.isle line 2482.
                            return Some(v1343);
                        }
                        F64 => {
                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);
                            let v1344 = &constructor_x64_movsd_store(ctx, v1330, v1341);
                            let v1345 = constructor_side_effect(ctx, v1344);
                            // Rule at src/isa/x64/lower.isle line 2490.
                            return Some(v1345);
                        }
                        F32X4 => {
                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);
                            let v1346 = &constructor_x64_movups_store(ctx, v1330, v1341);
                            let v1347 = constructor_side_effect(ctx, v1346);
                            // Rule at src/isa/x64/lower.isle line 2498.
                            return Some(v1347);
                        }
                        F64X2 => {
                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                            let v1341 = constructor_put_in_xmm(ctx, v1322.0);
                            let v1348 = &constructor_x64_movupd_store(ctx, v1330, v1341);
                            let v1349 = constructor_side_effect(ctx, v1348);
                            // Rule at src/isa/x64/lower.isle line 2506.
                            return Some(v1349);
                        }
                        _ => {}
                    }
                    let v1350 = C::ty_vec128_int(ctx, v1325);
                    if let Some(v1351) = v1350 {
                        let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                        let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                        let v1341 = constructor_put_in_xmm(ctx, v1322.0);
                        let v1352 = &constructor_x64_movdqu_store(ctx, v1330, v1341);
                        let v1353 = constructor_side_effect(ctx, v1352);
                        // Rule at src/isa/x64/lower.isle line 2514.
                        return Some(v1353);
                    }
                    let v1326 = &C::type_register_class(ctx, v1325);
                    if let Some(v1327) = v1326 {
                        if let &RegisterClass::Gpr {
                            single_register: v1328,
                        } = v1327
                        {
                            let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                            let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                            let v1331 = constructor_put_in_gpr(ctx, v1322.0);
                            let v1332 = &constructor_x64_movrm(ctx, v1325, v1330, v1331);
                            let v1333 = constructor_side_effect(ctx, v1332);
                            // Rule at src/isa/x64/lower.isle line 2463.
                            return Some(v1333);
                        }
                    }
                }
                &Opcode::Istore8 => {
                    let v1322 = C::unpack_value_array_2(ctx, v1319);
                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);
                    let v1335 = &constructor_x64_movrm(ctx, I8, v1330, v1331);
                    let v1336 = constructor_side_effect(ctx, v1335);
                    // Rule at src/isa/x64/lower.isle line 2471.
                    return Some(v1336);
                }
                &Opcode::Istore16 => {
                    let v1322 = C::unpack_value_array_2(ctx, v1319);
                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);
                    let v1337 = &constructor_x64_movrm(ctx, I16, v1330, v1331);
                    let v1338 = constructor_side_effect(ctx, v1337);
                    // Rule at src/isa/x64/lower.isle line 2474.
                    return Some(v1338);
                }
                &Opcode::Istore32 => {
                    let v1322 = C::unpack_value_array_2(ctx, v1319);
                    let v1329 = &constructor_to_amode(ctx, v1320, v1322.1, v1321);
                    let v1330 = &C::amode_to_synthetic_amode(ctx, v1329);
                    let v1331 = constructor_put_in_gpr(ctx, v1322.0);
                    let v1339 = &constructor_x64_movrm(ctx, I32, v1330, v1331);
                    let v1340 = constructor_side_effect(ctx, v1339);
                    // Rule at src/isa/x64/lower.isle line 2477.
                    return Some(v1340);
                }
                _ => {}
            }
        }
        &InstructionData::StoreNoOffset {
            opcode: ref v1470,
            args: ref v1471,
            flags: v1472,
        } => {
            if let &Opcode::AtomicStore = v1470 {
                let v1473 = C::unpack_value_array_2(ctx, v1471);
                let v1476 = C::value_type(ctx, v1473.0);
                let v1477 = C::fits_in_64(ctx, v1476);
                if let Some(v1478) = v1477 {
                    let v1479 = C::ty_int(ctx, v1476);
                    if let Some(v1480) = v1479 {
                        let v48 = C::zero_offset(ctx);
                        let v1481 = &constructor_to_amode(ctx, v1472, v1473.1, v48);
                        let v1482 = &C::amode_to_synthetic_amode(ctx, v1481);
                        let v1483 = constructor_put_in_gpr(ctx, v1473.0);
                        let v1484 = &constructor_x64_movrm(ctx, v1478, v1482, v1483);
                        let v1485 = &constructor_x64_mfence(ctx);
                        let v1486 = &constructor_side_effect_concat(ctx, v1484, v1485);
                        let v1487 = constructor_side_effect(ctx, v1486);
                        // Rule at src/isa/x64/lower.isle line 2740.
                        return Some(v1487);
                    }
                }
            }
        }
        &InstructionData::Ternary {
            opcode: ref v541,
            args: ref v542,
        } => {
            match v541 {
                &Opcode::Select => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v543 = C::unpack_value_array_3(ctx, v542);
                        let v809 = C::maybe_uextend(ctx, v543.0);
                        if let Some(v810) = v809 {
                            let v811 = C::def_inst(ctx, v810);
                            if let Some(v812) = v811 {
                                let v813 = &C::inst_data(ctx, v812);
                                match v813 {
                                    &InstructionData::FloatCompare {
                                        opcode: ref v814,
                                        args: ref v815,
                                        cond: ref v816,
                                    } => {
                                        if let &Opcode::Fcmp = v814 {
                                            if let &FloatCC::Equal = v816 {
                                                let v817 = C::unpack_value_array_2(ctx, v815);
                                                let v823 = &constructor_emit_fcmp(
                                                    ctx,
                                                    &FloatCC::NotEqual,
                                                    v817.0,
                                                    v817.1,
                                                );
                                                let v3 = C::value_type(ctx, v2);
                                                let v824 = constructor_lower_select_fcmp(
                                                    ctx, v3, v823, v543.2, v543.1,
                                                );
                                                // Rule at src/isa/x64/lower.isle line 1584.
                                                return Some(v824);
                                            }
                                            let v817 = C::unpack_value_array_2(ctx, v815);
                                            let v820 =
                                                &constructor_emit_fcmp(ctx, v816, v817.0, v817.1);
                                            let v3 = C::value_type(ctx, v2);
                                            let v821 = constructor_lower_select_fcmp(
                                                ctx, v3, v820, v543.1, v543.2,
                                            );
                                            // Rule at src/isa/x64/lower.isle line 1582.
                                            return Some(v821);
                                        }
                                    }
                                    &InstructionData::IntCompare {
                                        opcode: ref v825,
                                        args: ref v826,
                                        cond: ref v827,
                                    } => {
                                        if let &Opcode::Icmp = v825 {
                                            let v828 = C::unpack_value_array_2(ctx, v826);
                                            let v831 = C::value_type(ctx, v828.0);
                                            let v832 = C::fits_in_64(ctx, v831);
                                            if let Some(v833) = v832 {
                                                let v834 = &C::raw_operand_size_of_type(ctx, v833);
                                                let v835 =
                                                    &constructor_put_in_gpr_mem_imm(ctx, v828.1);
                                                let v836 = constructor_put_in_gpr(ctx, v828.0);
                                                let v837 =
                                                    &constructor_x64_cmp(ctx, v834, v835, v836);
                                                let v838 = &C::intcc_to_cc(ctx, v827);
                                                let v3 = C::value_type(ctx, v2);
                                                let v839 = &constructor_cmove_from_values(
                                                    ctx, v3, v838, v543.1, v543.2,
                                                );
                                                let v840 = constructor_with_flags(ctx, v837, v839);
                                                let v841 = C::output(ctx, v840);
                                                // Rule at src/isa/x64/lower.isle line 1598.
                                                return Some(v841);
                                            }
                                        }
                                    }
                                    _ => {}
                                }
                            }
                        }
                        let v842 = C::value_type(ctx, v543.0);
                        let v843 = C::fits_in_64(ctx, v842);
                        if let Some(v844) = v843 {
                            let v845 = &C::raw_operand_size_of_type(ctx, v844);
                            let v846 = constructor_put_in_gpr(ctx, v543.0);
                            let v847 = &C::gpr_to_gpr_mem_imm(ctx, v846);
                            let v848 = &constructor_x64_test(ctx, v845, v847, v846);
                            let v3 = C::value_type(ctx, v2);
                            let v850 =
                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v543.1, v543.2);
                            let v851 = constructor_with_flags(ctx, v848, v850);
                            let v852 = C::output(ctx, v851);
                            // Rule at src/isa/x64/lower.isle line 1605.
                            return Some(v852);
                        }
                        if v842 == I128 {
                            let v854 = C::put_in_regs(ctx, v543.0);
                            let v855 = &constructor_cmp_zero_i128(ctx, &CC::Z, v854);
                            let v856 = constructor_select_icmp(ctx, v855, v543.1, v543.2);
                            let v857 = C::output(ctx, v856);
                            // Rule at src/isa/x64/lower.isle line 1612.
                            return Some(v857);
                        }
                    }
                }
                &Opcode::SelectSpectreGuard => {
                    let v543 = C::unpack_value_array_3(ctx, v542);
                    let v1541 = C::def_inst(ctx, v543.0);
                    if let Some(v1542) = v1541 {
                        let v1543 = &C::inst_data(ctx, v1542);
                        if let &InstructionData::IntCompare {
                            opcode: ref v1544,
                            args: ref v1545,
                            cond: ref v1546,
                        } = v1543
                        {
                            if let &Opcode::Icmp = v1544 {
                                let v1547 = C::unpack_value_array_2(ctx, v1545);
                                let v1550 = &constructor_emit_cmp(ctx, v1546, v1547.0, v1547.1);
                                let v1551 = constructor_select_icmp(ctx, v1550, v543.1, v543.2);
                                let v1552 = C::output(ctx, v1551);
                                // Rule at src/isa/x64/lower.isle line 2851.
                                return Some(v1552);
                            }
                        }
                    }
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v842 = C::value_type(ctx, v543.0);
                        let v843 = C::fits_in_64(ctx, v842);
                        if let Some(v844) = v843 {
                            let v845 = &C::raw_operand_size_of_type(ctx, v844);
                            let v846 = constructor_put_in_gpr(ctx, v543.0);
                            let v847 = &C::gpr_to_gpr_mem_imm(ctx, v846);
                            let v848 = &constructor_x64_test(ctx, v845, v847, v846);
                            let v3 = C::value_type(ctx, v2);
                            let v850 =
                                &constructor_cmove_from_values(ctx, v3, &CC::NZ, v543.1, v543.2);
                            let v851 = constructor_with_flags(ctx, v848, v850);
                            let v852 = C::output(ctx, v851);
                            // Rule at src/isa/x64/lower.isle line 2854.
                            return Some(v852);
                        }
                        if v842 == I128 {
                            let v854 = C::put_in_regs(ctx, v543.0);
                            let v855 = &constructor_cmp_zero_i128(ctx, &CC::Z, v854);
                            let v856 = constructor_select_icmp(ctx, v855, v543.1, v543.2);
                            let v857 = C::output(ctx, v856);
                            // Rule at src/isa/x64/lower.isle line 2859.
                            return Some(v857);
                        }
                    }
                }
                &Opcode::Bitselect => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            let v543 = C::unpack_value_array_3(ctx, v542);
                            let v556 = constructor_all_ones_or_all_zeros(ctx, v543.0);
                            if let Some(v557) = v556 {
                                let v547 = constructor_put_in_xmm(ctx, v543.0);
                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);
                                let v559 = constructor_put_in_xmm(ctx, v543.2);
                                let v560 = constructor_x64_blend(ctx, v3, v547, v558, v559);
                                let v561 = constructor_output_xmm(ctx, v560);
                                // Rule at src/isa/x64/lower.isle line 1205.
                                return Some(v561);
                            }
                            let v547 = constructor_put_in_xmm(ctx, v543.0);
                            let v548 = constructor_put_in_xmm(ctx, v543.1);
                            let v549 = &C::xmm_to_xmm_mem(ctx, v547);
                            let v550 = constructor_sse_and(ctx, v3, v548, v549);
                            let v551 = &C::put_in_xmm_mem(ctx, v543.2);
                            let v552 = constructor_sse_and_not(ctx, v3, v547, v551);
                            let v553 = &C::xmm_to_xmm_mem(ctx, v550);
                            let v554 = constructor_sse_or(ctx, v3, v552, v553);
                            let v555 = constructor_output_xmm(ctx, v554);
                            // Rule at src/isa/x64/lower.isle line 1191.
                            return Some(v555);
                        }
                    }
                }
                &Opcode::X86Blendv => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v562 = constructor_put_in_xmm(ctx, v543.2);
                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);
                                let v563 = constructor_put_in_xmm(ctx, v543.0);
                                let v564 = constructor_x64_pblendvb(ctx, v562, v558, v563);
                                let v565 = constructor_output_xmm(ctx, v564);
                                // Rule at src/isa/x64/lower.isle line 1225.
                                return Some(v565);
                            }
                            I32X4 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v562 = constructor_put_in_xmm(ctx, v543.2);
                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);
                                let v563 = constructor_put_in_xmm(ctx, v543.0);
                                let v566 = constructor_x64_blendvps(ctx, v562, v558, v563);
                                let v567 = constructor_output_xmm(ctx, v566);
                                // Rule at src/isa/x64/lower.isle line 1229.
                                return Some(v567);
                            }
                            I64X2 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v562 = constructor_put_in_xmm(ctx, v543.2);
                                let v558 = &C::put_in_xmm_mem(ctx, v543.1);
                                let v563 = constructor_put_in_xmm(ctx, v543.0);
                                let v568 = constructor_x64_blendvpd(ctx, v562, v558, v563);
                                let v569 = constructor_output_xmm(ctx, v568);
                                // Rule at src/isa/x64/lower.isle line 1233.
                                return Some(v569);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fma => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v1248 = C::use_fma(ctx);
                        if v1248 == true {
                            let v3 = C::value_type(ctx, v2);
                            let v543 = C::unpack_value_array_3(ctx, v542);
                            let v1249 = constructor_fmadd(ctx, v3, v543.0, v543.1, v543.2);
                            let v1250 = constructor_output_xmm(ctx, v1249);
                            // Rule at src/isa/x64/lower.isle line 2361.
                            return Some(v1250);
                        }
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v1169 = C::put_in_reg(ctx, v543.0);
                                let v1170 = C::put_in_reg(ctx, v543.1);
                                let v1171 = C::put_in_reg(ctx, v543.2);
                                let v1172 =
                                    C::libcall_3(ctx, &LibCall::FmaF32, v1169, v1170, v1171);
                                let v1173 = constructor_output_reg(ctx, v1172);
                                // Rule at src/isa/x64/lower.isle line 2316.
                                return Some(v1173);
                            }
                            F64 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v1169 = C::put_in_reg(ctx, v543.0);
                                let v1170 = C::put_in_reg(ctx, v543.1);
                                let v1171 = C::put_in_reg(ctx, v543.2);
                                let v1175 =
                                    C::libcall_3(ctx, &LibCall::FmaF64, v1169, v1170, v1171);
                                let v1176 = constructor_output_reg(ctx, v1175);
                                // Rule at src/isa/x64/lower.isle line 2318.
                                return Some(v1176);
                            }
                            F32X4 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v547 = constructor_put_in_xmm(ctx, v543.0);
                                let v548 = constructor_put_in_xmm(ctx, v543.1);
                                let v559 = constructor_put_in_xmm(ctx, v543.2);
                                let v1177 = C::xmm_to_reg(ctx, v547);
                                let v1178 = C::xmm_to_reg(ctx, v548);
                                let v1179 = C::xmm_to_reg(ctx, v559);
                                let v1180 =
                                    C::libcall_3(ctx, &LibCall::FmaF32, v1177, v1178, v1179);
                                let v1181 = C::xmm_new(ctx, v1180);
                                let v1182 = &C::xmm_to_xmm_mem(ctx, v547);
                                let v1183 = constructor_x64_pshufd(ctx, v1182, 0x1);
                                let v1184 = C::xmm_to_reg(ctx, v1183);
                                let v1185 = &C::xmm_to_xmm_mem(ctx, v548);
                                let v1186 = constructor_x64_pshufd(ctx, v1185, 0x1);
                                let v1187 = C::xmm_to_reg(ctx, v1186);
                                let v1188 = &C::xmm_to_xmm_mem(ctx, v559);
                                let v1189 = constructor_x64_pshufd(ctx, v1188, 0x1);
                                let v1190 = C::xmm_to_reg(ctx, v1189);
                                let v1191 =
                                    C::libcall_3(ctx, &LibCall::FmaF32, v1184, v1187, v1190);
                                let v1192 = C::xmm_new(ctx, v1191);
                                let v1193 = &C::xmm_to_xmm_mem(ctx, v547);
                                let v1195 = constructor_x64_pshufd(ctx, v1193, 0x2);
                                let v1196 = C::xmm_to_reg(ctx, v1195);
                                let v1197 = &C::xmm_to_xmm_mem(ctx, v548);
                                let v1198 = constructor_x64_pshufd(ctx, v1197, 0x2);
                                let v1199 = C::xmm_to_reg(ctx, v1198);
                                let v1200 = &C::xmm_to_xmm_mem(ctx, v559);
                                let v1201 = constructor_x64_pshufd(ctx, v1200, 0x2);
                                let v1202 = C::xmm_to_reg(ctx, v1201);
                                let v1203 =
                                    C::libcall_3(ctx, &LibCall::FmaF32, v1196, v1199, v1202);
                                let v1204 = C::xmm_new(ctx, v1203);
                                let v1205 = &C::xmm_to_xmm_mem(ctx, v547);
                                let v1207 = constructor_x64_pshufd(ctx, v1205, 0x3);
                                let v1208 = C::xmm_to_reg(ctx, v1207);
                                let v1209 = &C::xmm_to_xmm_mem(ctx, v548);
                                let v1210 = constructor_x64_pshufd(ctx, v1209, 0x3);
                                let v1211 = C::xmm_to_reg(ctx, v1210);
                                let v1212 = &C::xmm_to_xmm_mem(ctx, v559);
                                let v1213 = constructor_x64_pshufd(ctx, v1212, 0x3);
                                let v1214 = C::xmm_to_reg(ctx, v1213);
                                let v1215 =
                                    C::libcall_3(ctx, &LibCall::FmaF32, v1208, v1211, v1214);
                                let v1216 = C::xmm_new(ctx, v1215);
                                let v1218 = C::xmm_to_reg(ctx, v1192);
                                let v1219 = &constructor_xmm_to_reg_mem(ctx, v1218);
                                let v1220 = &C::xmm_mem_to_reg_mem(ctx, v1219);
                                let v1221 =
                                    constructor_vec_insert_lane(ctx, F32X4, v1181, v1220, 0x1);
                                let v1222 = C::xmm_to_reg(ctx, v1204);
                                let v1223 = &constructor_xmm_to_reg_mem(ctx, v1222);
                                let v1224 = &C::xmm_mem_to_reg_mem(ctx, v1223);
                                let v1225 =
                                    constructor_vec_insert_lane(ctx, F32X4, v1221, v1224, 0x2);
                                let v1226 = C::xmm_to_reg(ctx, v1216);
                                let v1227 = &constructor_xmm_to_reg_mem(ctx, v1226);
                                let v1228 = &C::xmm_mem_to_reg_mem(ctx, v1227);
                                let v1229 =
                                    constructor_vec_insert_lane(ctx, F32X4, v1225, v1228, 0x3);
                                let v1230 = constructor_output_xmm(ctx, v1229);
                                // Rule at src/isa/x64/lower.isle line 2321.
                                return Some(v1230);
                            }
                            F64X2 => {
                                let v543 = C::unpack_value_array_3(ctx, v542);
                                let v547 = constructor_put_in_xmm(ctx, v543.0);
                                let v548 = constructor_put_in_xmm(ctx, v543.1);
                                let v559 = constructor_put_in_xmm(ctx, v543.2);
                                let v1177 = C::xmm_to_reg(ctx, v547);
                                let v1178 = C::xmm_to_reg(ctx, v548);
                                let v1179 = C::xmm_to_reg(ctx, v559);
                                let v1231 =
                                    C::libcall_3(ctx, &LibCall::FmaF64, v1177, v1178, v1179);
                                let v1232 = C::xmm_new(ctx, v1231);
                                let v1182 = &C::xmm_to_xmm_mem(ctx, v547);
                                let v1234 = constructor_x64_pshufd(ctx, v1182, 0xEE);
                                let v1235 = C::xmm_to_reg(ctx, v1234);
                                let v1185 = &C::xmm_to_xmm_mem(ctx, v548);
                                let v1236 = constructor_x64_pshufd(ctx, v1185, 0xEE);
                                let v1237 = C::xmm_to_reg(ctx, v1236);
                                let v1188 = &C::xmm_to_xmm_mem(ctx, v559);
                                let v1238 = constructor_x64_pshufd(ctx, v1188, 0xEE);
                                let v1239 = C::xmm_to_reg(ctx, v1238);
                                let v1240 =
                                    C::libcall_3(ctx, &LibCall::FmaF64, v1235, v1237, v1239);
                                let v1241 = C::xmm_new(ctx, v1240);
                                let v1243 = C::xmm_to_reg(ctx, v1241);
                                let v1244 = &constructor_xmm_to_reg_mem(ctx, v1243);
                                let v1245 = &C::xmm_mem_to_reg_mem(ctx, v1244);
                                let v1246 =
                                    constructor_vec_insert_lane(ctx, F64X2, v1232, v1245, 0x1);
                                let v1247 = constructor_output_xmm(ctx, v1246);
                                // Rule at src/isa/x64/lower.isle line 2345.
                                return Some(v1247);
                            }
                            _ => {}
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::TernaryImm8 {
            opcode: ref v570,
            args: ref v571,
            imm: v572,
        } => {
            if let &Opcode::Insertlane = v570 {
                let v573 = C::unpack_value_array_2(ctx, v571);
                let v578 = constructor_put_in_xmm(ctx, v573.0);
                let v579 = &C::put_in_reg_mem(ctx, v573.1);
                let v576 = C::value_type(ctx, v573.0);
                let v577 = C::u8_from_uimm8(ctx, v572);
                let v580 = constructor_vec_insert_lane(ctx, v576, v578, v579, v577);
                let v581 = constructor_output_xmm(ctx, v580);
                // Rule at src/isa/x64/lower.isle line 1239.
                return Some(v581);
            }
        }
        &InstructionData::Trap {
            opcode: ref v618,
            code: ref v619,
        } => {
            match v618 {
                &Opcode::Trap => {
                    let v620 = &constructor_x64_ud2(ctx, v619);
                    let v621 = constructor_side_effect(ctx, v620);
                    // Rule at src/isa/x64/lower.isle line 1365.
                    return Some(v621);
                }
                &Opcode::ResumableTrap => {
                    let v620 = &constructor_x64_ud2(ctx, v619);
                    let v621 = constructor_side_effect(ctx, v620);
                    // Rule at src/isa/x64/lower.isle line 1392.
                    return Some(v621);
                }
                _ => {}
            }
        }
        &InstructionData::Unary {
            opcode: ref v300,
            arg: v301,
        } => {
            match v300 {
                &Opcode::Splat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            match v65.0 {
                                0x20 => {
                                    if v65.1 == 0x4 {
                                        let v2109 = &C::sinkable_load(ctx, v301);
                                        if let Some(v2110) = v2109 {
                                            let v2167 = C::use_avx_simd(ctx);
                                            if v2167 == true {
                                                let v2168 =
                                                    &constructor_sink_load_to_xmm_mem(ctx, v2110);
                                                let v2169 =
                                                    constructor_x64_vbroadcastss(ctx, v2168);
                                                let v2170 = constructor_output_xmm(ctx, v2169);
                                                // Rule at src/isa/x64/lower.isle line 3843.
                                                return Some(v2170);
                                            }
                                            let v2113 = &C::sink_load(ctx, v2110);
                                            let v2114 = constructor_x64_movss_load(ctx, v2113);
                                            let v2164 = &C::xmm_to_xmm_mem(ctx, v2114);
                                            let v2165 =
                                                constructor_x64_shufps(ctx, v2114, v2164, 0x0);
                                            let v2166 = constructor_output_xmm(ctx, v2165);
                                            // Rule at src/isa/x64/lower.isle line 3840.
                                            return Some(v2166);
                                        }
                                    }
                                }
                                0x40 => {
                                    if v65.1 == 0x2 {
                                        let v2109 = &C::sinkable_load(ctx, v301);
                                        if let Some(v2110) = v2109 {
                                            let v2168 =
                                                &constructor_sink_load_to_xmm_mem(ctx, v2110);
                                            let v2177 = constructor_x64_movddup(ctx, v2168);
                                            let v2178 = constructor_output_xmm(ctx, v2177);
                                            // Rule at src/isa/x64/lower.isle line 3854.
                                            return Some(v2178);
                                        }
                                    }
                                }
                                _ => {}
                            }
                        }
                        match v3 {
                            I8X16 => {
                                let v2129 = &C::sinkable_load_exact(ctx, v301);
                                if let Some(v2130) = v2129 {
                                    let v2125 = C::use_avx2_simd(ctx);
                                    if v2125 == true {
                                        let v2138 = &constructor_sink_load_to_xmm_mem(ctx, v2130);
                                        let v2139 = constructor_x64_vpbroadcastb(ctx, v2138);
                                        let v2140 = constructor_output_xmm(ctx, v2139);
                                        // Rule at src/isa/x64/lower.isle line 3791.
                                        return Some(v2140);
                                    }
                                    let v2131 = constructor_xmm_uninit_value(ctx);
                                    let v2132 = &constructor_sink_load_to_gpr_mem(ctx, v2130);
                                    let v2133 = constructor_x64_pinsrb(ctx, v2131, v2132, 0x0);
                                    let v2134 = constructor_xmm_zero(ctx, I8X16);
                                    let v2135 = &C::xmm_to_xmm_mem(ctx, v2134);
                                    let v2136 = constructor_x64_pshufb(ctx, v2133, v2135);
                                    let v2137 = constructor_output_xmm(ctx, v2136);
                                    // Rule at src/isa/x64/lower.isle line 3789.
                                    return Some(v2137);
                                }
                                let v2125 = C::use_avx2_simd(ctx);
                                if v2125 == true {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);
                                    let v2127 = constructor_x64_vpbroadcastb(ctx, v2126);
                                    let v2128 = constructor_output_xmm(ctx, v2127);
                                    // Rule at src/isa/x64/lower.isle line 3786.
                                    return Some(v2128);
                                }
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                let v2121 = constructor_xmm_zero(ctx, I8X16);
                                let v2122 = &C::xmm_to_xmm_mem(ctx, v2121);
                                let v2123 = constructor_x64_pshufb(ctx, v2120, v2122);
                                let v2124 = constructor_output_xmm(ctx, v2123);
                                // Rule at src/isa/x64/lower.isle line 3784.
                                return Some(v2124);
                            }
                            I16X8 => {
                                let v2129 = &C::sinkable_load_exact(ctx, v301);
                                if let Some(v2130) = v2129 {
                                    let v2125 = C::use_avx2_simd(ctx);
                                    if v2125 == true {
                                        let v2138 = &constructor_sink_load_to_xmm_mem(ctx, v2130);
                                        let v2153 = constructor_x64_vpbroadcastw(ctx, v2138);
                                        let v2154 = constructor_output_xmm(ctx, v2153);
                                        // Rule at src/isa/x64/lower.isle line 3807.
                                        return Some(v2154);
                                    }
                                    let v2131 = constructor_xmm_uninit_value(ctx);
                                    let v2132 = &constructor_sink_load_to_gpr_mem(ctx, v2130);
                                    let v2147 = constructor_x64_pinsrw(ctx, v2131, v2132, 0x0);
                                    let v2148 = &C::xmm_to_xmm_mem(ctx, v2147);
                                    let v2149 = constructor_x64_pshuflw(ctx, v2148, 0x0);
                                    let v2150 = &C::xmm_to_xmm_mem(ctx, v2149);
                                    let v2151 = constructor_x64_pshufd(ctx, v2150, 0x0);
                                    let v2152 = constructor_output_xmm(ctx, v2151);
                                    // Rule at src/isa/x64/lower.isle line 3805.
                                    return Some(v2152);
                                }
                                let v2125 = C::use_avx2_simd(ctx);
                                if v2125 == true {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);
                                    let v2145 = constructor_x64_vpbroadcastw(ctx, v2126);
                                    let v2146 = constructor_output_xmm(ctx, v2145);
                                    // Rule at src/isa/x64/lower.isle line 3802.
                                    return Some(v2146);
                                }
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);
                                let v2141 = constructor_x64_pshuflw(ctx, v2126, 0x0);
                                let v2142 = &C::xmm_to_xmm_mem(ctx, v2141);
                                let v2143 = constructor_x64_pshufd(ctx, v2142, 0x0);
                                let v2144 = constructor_output_xmm(ctx, v2143);
                                // Rule at src/isa/x64/lower.isle line 3800.
                                return Some(v2144);
                            }
                            I32X4 => {
                                let v2125 = C::use_avx2_simd(ctx);
                                if v2125 == true {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                    let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);
                                    let v2157 = constructor_x64_vpbroadcastd(ctx, v2126);
                                    let v2158 = constructor_output_xmm(ctx, v2157);
                                    // Rule at src/isa/x64/lower.isle line 3817.
                                    return Some(v2158);
                                }
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v2120 = constructor_bitcast_gpr_to_xmm(ctx, I32, v302);
                                let v2126 = &C::xmm_to_xmm_mem(ctx, v2120);
                                let v2155 = constructor_x64_pshufd(ctx, v2126, 0x0);
                                let v2156 = constructor_output_xmm(ctx, v2155);
                                // Rule at src/isa/x64/lower.isle line 3815.
                                return Some(v2156);
                            }
                            I64X2 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v2171 = constructor_bitcast_gpr_to_xmm(ctx, I64, v302);
                                let v2172 = &C::xmm_to_xmm_mem(ctx, v2171);
                                let v2173 = constructor_x64_movddup(ctx, v2172);
                                let v2174 = constructor_output_xmm(ctx, v2173);
                                // Rule at src/isa/x64/lower.isle line 3850.
                                return Some(v2174);
                            }
                            F32X4 => {
                                let v2125 = C::use_avx2_simd(ctx);
                                if v2125 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v2162 = constructor_x64_vbroadcastss(ctx, v459);
                                    let v2163 = constructor_output_xmm(ctx, v2162);
                                    // Rule at src/isa/x64/lower.isle line 3827.
                                    return Some(v2163);
                                }
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v2159 = constructor_put_in_xmm(ctx, v301);
                                let v317 = &C::put_in_xmm_mem(ctx, v301);
                                let v2160 = constructor_x64_shufps(ctx, v2159, v317, 0x0);
                                let v2161 = constructor_output_xmm(ctx, v2160);
                                // Rule at src/isa/x64/lower.isle line 3824.
                                return Some(v2161);
                            }
                            F64X2 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v2175 = constructor_x64_movddup(ctx, v459);
                                let v2176 = constructor_output_xmm(ctx, v2175);
                                // Rule at src/isa/x64/lower.isle line 3852.
                                return Some(v2176);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SetPinnedReg => {
                    let v302 = constructor_put_in_gpr(ctx, v301);
                    let v1960 = &constructor_write_pinned_gpr(ctx, v302);
                    let v1961 = constructor_side_effect(ctx, v1960);
                    // Rule at src/isa/x64/lower.isle line 3543.
                    return Some(v1961);
                }
                &Opcode::VanyTrue => {
                    let v469 = constructor_put_in_xmm(ctx, v301);
                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                    let v2179 = &constructor_x64_ptest(ctx, v1075, v469);
                    let v2180 = &constructor_x64_setcc(ctx, &CC::NZ);
                    let v2181 = constructor_with_flags(ctx, v2179, v2180);
                    let v2182 = C::output(ctx, v2181);
                    // Rule at src/isa/x64/lower.isle line 3859.
                    return Some(v2182);
                }
                &Opcode::VallTrue => {
                    let v469 = constructor_put_in_xmm(ctx, v301);
                    let v529 = C::value_type(ctx, v301);
                    let v2183 = constructor_xmm_zero(ctx, v529);
                    let v2184 = constructor_vec_int_type(ctx, v529);
                    let v2185 = &C::xmm_to_xmm_mem(ctx, v2183);
                    let v2186 = constructor_x64_pcmpeq(ctx, v2184, v469, v2185);
                    let v2187 = &C::xmm_to_xmm_mem(ctx, v2186);
                    let v2188 = &constructor_x64_ptest(ctx, v2187, v2186);
                    let v2189 = &constructor_x64_setcc(ctx, &CC::Z);
                    let v2190 = constructor_with_flags(ctx, v2188, v2189);
                    let v2191 = C::output(ctx, v2190);
                    // Rule at src/isa/x64/lower.isle line 3865.
                    return Some(v2191);
                }
                &Opcode::VhighBits => {
                    let v529 = C::value_type(ctx, v301);
                    let v2192 = C::multi_lane(ctx, v529);
                    if let Some(v2193) = v2192 {
                        match v2193.0 {
                            0x8 => {
                                if v2193.1 == 0x10 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v2197 =
                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v469);
                                    let v2198 = constructor_output_gpr(ctx, v2197);
                                    // Rule at src/isa/x64/lower.isle line 3882.
                                    return Some(v2198);
                                }
                            }
                            0x10 => {
                                if v2193.1 == 0x8 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                    let v2203 = constructor_x64_packsswb(ctx, v469, v1075);
                                    let v2204 =
                                        constructor_x64_pmovmskb(ctx, &OperandSize::Size32, v2203);
                                    let v968 = Imm8Reg::Imm8 { imm: 0x8 };
                                    let v1909 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);
                                    let v2205 = constructor_x64_shr(ctx, I64, v2204, v1909);
                                    let v2206 = constructor_output_gpr(ctx, v2205);
                                    // Rule at src/isa/x64/lower.isle line 3897.
                                    return Some(v2206);
                                }
                            }
                            0x20 => {
                                if v2193.1 == 0x4 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v2199 =
                                        constructor_x64_movmskps(ctx, &OperandSize::Size32, v469);
                                    let v2200 = constructor_output_gpr(ctx, v2199);
                                    // Rule at src/isa/x64/lower.isle line 3885.
                                    return Some(v2200);
                                }
                            }
                            0x40 => {
                                if v2193.1 == 0x2 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v2201 =
                                        constructor_x64_movmskpd(ctx, &OperandSize::Size32, v469);
                                    let v2202 = constructor_output_gpr(ctx, v2201);
                                    // Rule at src/isa/x64/lower.isle line 3888.
                                    return Some(v2202);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ineg => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v315 = constructor_imm(ctx, I8X16, 0x0);
                                let v316 = C::xmm_new(ctx, v315);
                                let v317 = &C::put_in_xmm_mem(ctx, v301);
                                let v318 = constructor_x64_psubb(ctx, v316, v317);
                                let v319 = constructor_output_xmm(ctx, v318);
                                // Rule at src/isa/x64/lower.isle line 765.
                                return Some(v319);
                            }
                            I16X8 => {
                                let v321 = constructor_imm(ctx, I16X8, 0x0);
                                let v322 = C::xmm_new(ctx, v321);
                                let v317 = &C::put_in_xmm_mem(ctx, v301);
                                let v323 = constructor_x64_psubw(ctx, v322, v317);
                                let v324 = constructor_output_xmm(ctx, v323);
                                // Rule at src/isa/x64/lower.isle line 768.
                                return Some(v324);
                            }
                            I32X4 => {
                                let v326 = constructor_imm(ctx, I32X4, 0x0);
                                let v327 = C::xmm_new(ctx, v326);
                                let v317 = &C::put_in_xmm_mem(ctx, v301);
                                let v328 = constructor_x64_psubd(ctx, v327, v317);
                                let v329 = constructor_output_xmm(ctx, v328);
                                // Rule at src/isa/x64/lower.isle line 771.
                                return Some(v329);
                            }
                            I64X2 => {
                                let v331 = constructor_imm(ctx, I64X2, 0x0);
                                let v332 = C::xmm_new(ctx, v331);
                                let v317 = &C::put_in_xmm_mem(ctx, v301);
                                let v333 = constructor_x64_psubq(ctx, v332, v317);
                                let v334 = constructor_output_xmm(ctx, v333);
                                // Rule at src/isa/x64/lower.isle line 774.
                                return Some(v334);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v302 = constructor_put_in_gpr(ctx, v301);
                            let v303 = constructor_x64_neg(ctx, v5, v302);
                            let v304 = constructor_output_gpr(ctx, v303);
                            // Rule at src/isa/x64/lower.isle line 751.
                            return Some(v304);
                        }
                        if v3 == I128 {
                            let v305 = C::put_in_regs(ctx, v301);
                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);
                            let v307 = constructor_value_regs_get_gpr(ctx, v305, 0x1);
                            let v308 = &constructor_x64_neg_paired(ctx, I64, v306);
                            let v309 = constructor_imm(ctx, I64, 0x0);
                            let v310 = C::gpr_new(ctx, v309);
                            let v311 = &C::gpr_to_gpr_mem_imm(ctx, v307);
                            let v312 = &constructor_x64_sbb_paired(ctx, I64, v310, v311);
                            let v313 = constructor_with_flags(ctx, v308, v312);
                            let v314 = C::output(ctx, v313);
                            // Rule at src/isa/x64/lower.isle line 754.
                            return Some(v314);
                        }
                    }
                }
                &Opcode::Iabs => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8X16 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v460 = constructor_x64_pabsb(ctx, v459);
                                let v461 = constructor_output_xmm(ctx, v460);
                                // Rule at src/isa/x64/lower.isle line 1040.
                                return Some(v461);
                            }
                            I16X8 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v462 = constructor_x64_pabsw(ctx, v459);
                                let v463 = constructor_output_xmm(ctx, v462);
                                // Rule at src/isa/x64/lower.isle line 1043.
                                return Some(v463);
                            }
                            I32X4 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v464 = constructor_x64_pabsd(ctx, v459);
                                let v465 = constructor_output_xmm(ctx, v464);
                                // Rule at src/isa/x64/lower.isle line 1046.
                                return Some(v465);
                            }
                            I64X2 => {
                                let v363 = C::avx512vl_enabled(ctx, v3);
                                if v363 == true {
                                    let v466 = C::avx512f_enabled(ctx, v3);
                                    if v466 == true {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v467 = constructor_x64_vpabsq(ctx, v459);
                                        let v468 = constructor_output_xmm(ctx, v467);
                                        // Rule at src/isa/x64/lower.isle line 1050.
                                        return Some(v468);
                                    }
                                }
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v470 = constructor_imm(ctx, I64X2, 0x0);
                                let v471 = C::xmm_new(ctx, v470);
                                let v472 = &C::xmm_to_xmm_mem(ctx, v469);
                                let v473 = constructor_x64_psubq(ctx, v471, v472);
                                let v474 = &C::xmm_to_xmm_mem(ctx, v469);
                                let v475 = constructor_x64_blendvpd(ctx, v473, v474, v473);
                                let v476 = constructor_output_xmm(ctx, v475);
                                // Rule at src/isa/x64/lower.isle line 1060.
                                return Some(v476);
                            }
                            _ => {}
                        }
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v302 = constructor_put_in_gpr(ctx, v301);
                            let v477 = &constructor_x64_neg_paired(ctx, v5, v302);
                            let v478 = constructor_produces_flags_get_reg(ctx, v477);
                            let v479 = C::gpr_new(ctx, v478);
                            let v481 = &C::gpr_to_gpr_mem(ctx, v302);
                            let v482 = &constructor_cmove(ctx, v5, &CC::S, v481, v479);
                            let v483 = &constructor_produces_flags_ignore(ctx, v477);
                            let v484 = constructor_with_flags_reg(ctx, v483, v482);
                            let v485 = constructor_output_reg(ctx, v484);
                            // Rule at src/isa/x64/lower.isle line 1067.
                            return Some(v485);
                        }
                    }
                }
                &Opcode::Bnot => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I128 {
                            let v534 = constructor_i128_not(ctx, v301);
                            let v535 = C::output(ctx, v534);
                            // Rule at src/isa/x64/lower.isle line 1176.
                            return Some(v535);
                        }
                        let v64 = C::multi_lane(ctx, v3);
                        if let Some(v65) = v64 {
                            let v469 = constructor_put_in_xmm(ctx, v301);
                            let v496 = constructor_vector_all_ones(ctx);
                            let v536 = &C::xmm_to_xmm_mem(ctx, v496);
                            let v539 = constructor_x64_xor_vector(ctx, v3, v469, v536);
                            let v540 = constructor_output_xmm(ctx, v539);
                            // Rule at src/isa/x64/lower.isle line 1186.
                            return Some(v540);
                        }
                        let v134 = C::ty_int_ref_scalar_64(ctx, v3);
                        if let Some(v135) = v134 {
                            let v302 = constructor_put_in_gpr(ctx, v301);
                            let v532 = constructor_x64_not(ctx, v3, v302);
                            let v533 = constructor_output_gpr(ctx, v532);
                            // Rule at src/isa/x64/lower.isle line 1161.
                            return Some(v533);
                        }
                        let v144 = C::ty_scalar_float(ctx, v3);
                        if let Some(v145) = v144 {
                            let v469 = constructor_put_in_xmm(ctx, v301);
                            let v496 = constructor_vector_all_ones(ctx);
                            let v536 = &C::xmm_to_xmm_mem(ctx, v496);
                            let v537 = constructor_x64_xor_vector(ctx, v145, v469, v536);
                            let v538 = constructor_output_xmm(ctx, v537);
                            // Rule at src/isa/x64/lower.isle line 1181.
                            return Some(v538);
                        }
                    }
                }
                &Opcode::Bitrev => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I8 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v951 = constructor_do_bitrev8(ctx, I32, v302);
                                let v952 = constructor_output_gpr(ctx, v951);
                                // Rule at src/isa/x64/lower.isle line 1861.
                                return Some(v952);
                            }
                            I16 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v953 = constructor_do_bitrev16(ctx, I32, v302);
                                let v954 = constructor_output_gpr(ctx, v953);
                                // Rule at src/isa/x64/lower.isle line 1864.
                                return Some(v954);
                            }
                            I32 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v955 = constructor_do_bitrev32(ctx, I32, v302);
                                let v956 = constructor_output_gpr(ctx, v955);
                                // Rule at src/isa/x64/lower.isle line 1867.
                                return Some(v956);
                            }
                            I64 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v957 = constructor_do_bitrev64(ctx, I64, v302);
                                let v958 = constructor_output_gpr(ctx, v957);
                                // Rule at src/isa/x64/lower.isle line 1870.
                                return Some(v958);
                            }
                            I128 => {
                                let v305 = C::put_in_regs(ctx, v301);
                                let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);
                                let v959 = constructor_do_bitrev64(ctx, I64, v868);
                                let v960 = C::gpr_to_reg(ctx, v959);
                                let v961 = C::put_in_regs(ctx, v301);
                                let v962 = constructor_value_regs_get_gpr(ctx, v961, 0x0);
                                let v963 = constructor_do_bitrev64(ctx, I64, v962);
                                let v964 = C::gpr_to_reg(ctx, v963);
                                let v965 = C::value_regs(ctx, v960, v964);
                                let v966 = C::output(ctx, v965);
                                // Rule at src/isa/x64/lower.isle line 1873.
                                return Some(v966);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Clz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v45 = C::ty_32_or_64(ctx, v3);
                        if let Some(v46) = v45 {
                            let v858 = C::use_lzcnt(ctx, v3);
                            match v858 {
                                true => {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v859 = constructor_x64_lzcnt(ctx, v46, v302);
                                    let v860 = constructor_output_gpr(ctx, v859);
                                    // Rule at src/isa/x64/lower.isle line 1622.
                                    return Some(v860);
                                }
                                false => {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v861 = constructor_do_clz(ctx, v46, v46, v302);
                                    let v862 = constructor_output_gpr(ctx, v861);
                                    // Rule at src/isa/x64/lower.isle line 1629.
                                    return Some(v862);
                                }
                                _ => {}
                            }
                        }
                        let v863 = C::ty_8_or_16(ctx, v3);
                        if let Some(v864) = v863 {
                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);
                            let v866 = constructor_do_clz(ctx, I32, v864, v865);
                            let v867 = constructor_output_gpr(ctx, v866);
                            // Rule at src/isa/x64/lower.isle line 1636.
                            return Some(v867);
                        }
                        if v3 == I128 {
                            let v305 = C::put_in_regs(ctx, v301);
                            let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);
                            let v869 = constructor_do_clz(ctx, I64, I64, v868);
                            let v870 = C::put_in_regs(ctx, v301);
                            let v871 = constructor_value_regs_get_gpr(ctx, v870, 0x0);
                            let v872 = constructor_do_clz(ctx, I64, I64, v871);
                            let v874 = RegMemImm::Imm { simm32: 0x40 };
                            let v875 = &C::gpr_mem_imm_new(ctx, &v874);
                            let v876 = constructor_x64_add(ctx, I64, v872, v875);
                            let v878 =
                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v869);
                            let v879 = &C::gpr_to_gpr_mem(ctx, v869);
                            let v880 = &constructor_cmove(ctx, I64, &CC::NZ, v879, v876);
                            let v881 = constructor_with_flags_reg(ctx, v878, v880);
                            let v882 = C::gpr_new(ctx, v881);
                            let v883 = C::gpr_to_reg(ctx, v882);
                            let v884 = constructor_imm(ctx, I64, 0x0);
                            let v885 = C::value_regs(ctx, v883, v884);
                            let v886 = C::output(ctx, v885);
                            // Rule at src/isa/x64/lower.isle line 1641.
                            return Some(v886);
                        }
                    }
                }
                &Opcode::Ctz => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v45 = C::ty_32_or_64(ctx, v3);
                        if let Some(v46) = v45 {
                            let v171 = C::use_bmi1(ctx, v3);
                            match v171 {
                                true => {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v887 = constructor_x64_tzcnt(ctx, v46, v302);
                                    let v888 = constructor_output_gpr(ctx, v887);
                                    // Rule at src/isa/x64/lower.isle line 1666.
                                    return Some(v888);
                                }
                                false => {
                                    let v302 = constructor_put_in_gpr(ctx, v301);
                                    let v889 = constructor_do_ctz(ctx, v46, v46, v302);
                                    let v890 = constructor_output_gpr(ctx, v889);
                                    // Rule at src/isa/x64/lower.isle line 1673.
                                    return Some(v890);
                                }
                                _ => {}
                            }
                        }
                        let v863 = C::ty_8_or_16(ctx, v3);
                        if let Some(v864) = v863 {
                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);
                            let v891 = constructor_do_ctz(ctx, I32, v864, v865);
                            let v892 = constructor_output_gpr(ctx, v891);
                            // Rule at src/isa/x64/lower.isle line 1680.
                            return Some(v892);
                        }
                        if v3 == I128 {
                            let v305 = C::put_in_regs(ctx, v301);
                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);
                            let v893 = constructor_do_ctz(ctx, I64, I64, v306);
                            let v870 = C::put_in_regs(ctx, v301);
                            let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);
                            let v895 = constructor_do_ctz(ctx, I64, I64, v894);
                            let v874 = RegMemImm::Imm { simm32: 0x40 };
                            let v875 = &C::gpr_mem_imm_new(ctx, &v874);
                            let v896 = constructor_x64_add(ctx, I64, v895, v875);
                            let v897 =
                                &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x40, v893);
                            let v898 = &C::gpr_to_gpr_mem(ctx, v896);
                            let v899 = &constructor_cmove(ctx, I64, &CC::Z, v898, v893);
                            let v900 = constructor_with_flags_reg(ctx, v897, v899);
                            let v901 = C::gpr_new(ctx, v900);
                            let v902 = C::gpr_to_reg(ctx, v901);
                            let v884 = constructor_imm(ctx, I64, 0x0);
                            let v903 = C::value_regs(ctx, v902, v884);
                            let v904 = C::output(ctx, v903);
                            // Rule at src/isa/x64/lower.isle line 1685.
                            return Some(v904);
                        }
                    }
                }
                &Opcode::Bswap => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v968 = Imm8Reg::Imm8 { imm: 0x8 };
                                let v969 = &C::imm8_reg_to_imm8_gpr(ctx, &v968);
                                let v970 = constructor_x64_rotl(ctx, I16, v302, v969);
                                let v971 = constructor_output_gpr(ctx, v970);
                                // Rule at src/isa/x64/lower.isle line 1940.
                                return Some(v971);
                            }
                            I32 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v972 = constructor_x64_bswap(ctx, I32, v302);
                                let v973 = constructor_output_gpr(ctx, v972);
                                // Rule at src/isa/x64/lower.isle line 1943.
                                return Some(v973);
                            }
                            I64 => {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v974 = constructor_x64_bswap(ctx, I64, v302);
                                let v975 = constructor_output_gpr(ctx, v974);
                                // Rule at src/isa/x64/lower.isle line 1946.
                                return Some(v975);
                            }
                            I128 => {
                                let v305 = C::put_in_regs(ctx, v301);
                                let v868 = constructor_value_regs_get_gpr(ctx, v305, 0x1);
                                let v976 = constructor_x64_bswap(ctx, I64, v868);
                                let v977 = C::gpr_to_reg(ctx, v976);
                                let v961 = C::put_in_regs(ctx, v301);
                                let v962 = constructor_value_regs_get_gpr(ctx, v961, 0x0);
                                let v978 = constructor_x64_bswap(ctx, I64, v962);
                                let v979 = C::gpr_to_reg(ctx, v978);
                                let v980 = C::value_regs(ctx, v977, v979);
                                let v981 = C::output(ctx, v980);
                                // Rule at src/isa/x64/lower.isle line 1949.
                                return Some(v981);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Popcnt => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v905 = C::use_popcnt(ctx, v3);
                        if v905 == true {
                            let v45 = C::ty_32_or_64(ctx, v3);
                            if let Some(v46) = v45 {
                                let v302 = constructor_put_in_gpr(ctx, v301);
                                let v906 = constructor_x64_popcnt(ctx, v46, v302);
                                let v907 = constructor_output_gpr(ctx, v906);
                                // Rule at src/isa/x64/lower.isle line 1704.
                                return Some(v907);
                            }
                            let v863 = C::ty_8_or_16(ctx, v3);
                            if let Some(v864) = v863 {
                                let v865 =
                                    constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);
                                let v908 = constructor_x64_popcnt(ctx, I32, v865);
                                let v909 = constructor_output_gpr(ctx, v908);
                                // Rule at src/isa/x64/lower.isle line 1711.
                                return Some(v909);
                            }
                            if v3 == I128 {
                                let v305 = C::put_in_regs(ctx, v301);
                                let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);
                                let v910 = constructor_x64_popcnt(ctx, I64, v306);
                                let v870 = C::put_in_regs(ctx, v301);
                                let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);
                                let v911 = constructor_x64_popcnt(ctx, I64, v894);
                                let v912 = &C::gpr_to_gpr_mem_imm(ctx, v911);
                                let v913 = constructor_x64_add(ctx, I64, v910, v912);
                                let v914 = C::gpr_to_reg(ctx, v913);
                                let v915 = constructor_imm(ctx, I64, 0x0);
                                let v916 = C::value_regs(ctx, v914, v915);
                                let v917 = C::output(ctx, v916);
                                // Rule at src/isa/x64/lower.isle line 1718.
                                return Some(v917);
                            }
                        }
                        match v3 {
                            I128 => {
                                let v305 = C::put_in_regs(ctx, v301);
                                let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);
                                let v922 = constructor_do_popcnt(ctx, I64, v306);
                                let v870 = C::put_in_regs(ctx, v301);
                                let v894 = constructor_value_regs_get_gpr(ctx, v870, 0x1);
                                let v923 = constructor_do_popcnt(ctx, I64, v894);
                                let v924 = &C::gpr_to_gpr_mem_imm(ctx, v923);
                                let v925 = constructor_x64_add(ctx, I64, v922, v924);
                                let v926 = C::gpr_to_reg(ctx, v925);
                                let v915 = constructor_imm(ctx, I64, 0x0);
                                let v927 = C::value_regs(ctx, v926, v915);
                                let v928 = C::output(ctx, v927);
                                // Rule at src/isa/x64/lower.isle line 1737.
                                return Some(v928);
                            }
                            I8X16 => {
                                let v363 = C::avx512vl_enabled(ctx, v3);
                                if v363 == true {
                                    let v929 = C::avx512bitalg_enabled(ctx, v3);
                                    if v929 == true {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v930 = constructor_x64_vpopcntb(ctx, v459);
                                        let v931 = constructor_output_xmm(ctx, v930);
                                        // Rule at src/isa/x64/lower.isle line 1810.
                                        return Some(v931);
                                    }
                                }
                                let v932 = C::popcount_4bit_table(ctx);
                                let v933 = C::popcount_low_mask(ctx);
                                let v934 = &constructor_const_to_xmm_mem(ctx, v933);
                                let v935 = constructor_put_in_xmm(ctx, v301);
                                let v936 = constructor_sse_and(ctx, I8X16, v935, v934);
                                let v937 = constructor_put_in_xmm(ctx, v301);
                                let v939 = &C::xmi_imm(ctx, 0x4);
                                let v940 = constructor_x64_psrlw(ctx, v937, v939);
                                let v941 = constructor_sse_and(ctx, I8X16, v940, v934);
                                let v942 = C::popcount_4bit_table(ctx);
                                let v943 = constructor_x64_xmm_load_const(ctx, I8X16, v942);
                                let v944 = &C::xmm_to_xmm_mem(ctx, v936);
                                let v945 = constructor_x64_pshufb(ctx, v943, v944);
                                let v946 = &C::xmm_to_xmm_mem(ctx, v941);
                                let v947 = constructor_x64_pshufb(ctx, v943, v946);
                                let v948 = &C::xmm_to_xmm_mem(ctx, v947);
                                let v949 = constructor_x64_paddb(ctx, v945, v948);
                                let v950 = constructor_output_xmm(ctx, v949);
                                // Rule at src/isa/x64/lower.isle line 1844.
                                return Some(v950);
                            }
                            _ => {}
                        }
                        let v45 = C::ty_32_or_64(ctx, v3);
                        if let Some(v46) = v45 {
                            let v302 = constructor_put_in_gpr(ctx, v301);
                            let v918 = constructor_do_popcnt(ctx, v46, v302);
                            let v919 = constructor_output_gpr(ctx, v918);
                            // Rule at src/isa/x64/lower.isle line 1727.
                            return Some(v919);
                        }
                        let v863 = C::ty_8_or_16(ctx, v3);
                        if let Some(v864) = v863 {
                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);
                            let v920 = constructor_do_popcnt(ctx, I32, v865);
                            let v921 = constructor_output_gpr(ctx, v920);
                            // Rule at src/isa/x64/lower.isle line 1732.
                            return Some(v921);
                        }
                    }
                }
                &Opcode::Sqrt => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v1065 = constructor_x64_sqrtss(ctx, v459);
                                let v1066 = constructor_output_xmm(ctx, v1065);
                                // Rule at src/isa/x64/lower.isle line 2095.
                                return Some(v1066);
                            }
                            F64 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v1067 = constructor_x64_sqrtsd(ctx, v459);
                                let v1068 = constructor_output_xmm(ctx, v1067);
                                // Rule at src/isa/x64/lower.isle line 2097.
                                return Some(v1068);
                            }
                            F32X4 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v1069 = constructor_x64_sqrtps(ctx, v459);
                                let v1070 = constructor_output_xmm(ctx, v1069);
                                // Rule at src/isa/x64/lower.isle line 2099.
                                return Some(v1070);
                            }
                            F64X2 => {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v1071 = constructor_x64_sqrtpd(ctx, v459);
                                let v1072 = constructor_output_xmm(ctx, v1071);
                                // Rule at src/isa/x64/lower.isle line 2101.
                                return Some(v1072);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fneg => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v508 = constructor_imm(ctx, F32, 0x80000000);
                                let v509 = &constructor_reg_to_xmm_mem(ctx, v508);
                                let v510 = constructor_x64_xorps(ctx, v469, v509);
                                let v511 = constructor_output_xmm(ctx, v510);
                                // Rule at src/isa/x64/lower.isle line 1099.
                                return Some(v511);
                            }
                            F64 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v513 = constructor_imm(ctx, F64, 0x8000000000000000);
                                let v514 = &constructor_reg_to_xmm_mem(ctx, v513);
                                let v515 = constructor_x64_xorpd(ctx, v469, v514);
                                let v516 = constructor_output_xmm(ctx, v515);
                                // Rule at src/isa/x64/lower.isle line 1102.
                                return Some(v516);
                            }
                            F32X4 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v496 = constructor_vector_all_ones(ctx);
                                let v518 = &C::xmi_imm(ctx, 0x1F);
                                let v519 = constructor_x64_pslld(ctx, v496, v518);
                                let v520 = &C::xmm_to_xmm_mem(ctx, v519);
                                let v521 = constructor_x64_xorps(ctx, v469, v520);
                                let v522 = constructor_output_xmm(ctx, v521);
                                // Rule at src/isa/x64/lower.isle line 1105.
                                return Some(v522);
                            }
                            F64X2 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v496 = constructor_vector_all_ones(ctx);
                                let v524 = &C::xmi_imm(ctx, 0x3F);
                                let v525 = constructor_x64_psllq(ctx, v496, v524);
                                let v526 = &C::xmm_to_xmm_mem(ctx, v525);
                                let v527 = constructor_x64_xorpd(ctx, v469, v526);
                                let v528 = constructor_output_xmm(ctx, v527);
                                // Rule at src/isa/x64/lower.isle line 1109.
                                return Some(v528);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Fabs => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v487 = constructor_imm(ctx, F32, 0x7FFFFFFF);
                                let v488 = &constructor_reg_to_xmm_mem(ctx, v487);
                                let v489 = constructor_x64_andps(ctx, v469, v488);
                                let v490 = constructor_output_xmm(ctx, v489);
                                // Rule at src/isa/x64/lower.isle line 1081.
                                return Some(v490);
                            }
                            F64 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v492 = constructor_imm(ctx, F64, 0x7FFFFFFFFFFFFFFF);
                                let v493 = &constructor_reg_to_xmm_mem(ctx, v492);
                                let v494 = constructor_x64_andpd(ctx, v469, v493);
                                let v495 = constructor_output_xmm(ctx, v494);
                                // Rule at src/isa/x64/lower.isle line 1084.
                                return Some(v495);
                            }
                            F32X4 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v496 = constructor_vector_all_ones(ctx);
                                let v498 = &C::xmi_imm(ctx, 0x1);
                                let v499 = constructor_x64_psrld(ctx, v496, v498);
                                let v500 = &C::xmm_to_xmm_mem(ctx, v499);
                                let v501 = constructor_x64_andps(ctx, v469, v500);
                                let v502 = constructor_output_xmm(ctx, v501);
                                // Rule at src/isa/x64/lower.isle line 1088.
                                return Some(v502);
                            }
                            F64X2 => {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v496 = constructor_vector_all_ones(ctx);
                                let v498 = &C::xmi_imm(ctx, 0x1);
                                let v503 = constructor_x64_psrlq(ctx, v496, v498);
                                let v504 = &C::xmm_to_xmm_mem(ctx, v503);
                                let v505 = constructor_x64_andpd(ctx, v469, v504);
                                let v506 = constructor_output_xmm(ctx, v505);
                                // Rule at src/isa/x64/lower.isle line 1093.
                                return Some(v506);
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Ceil => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        match v529 {
                            F32 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1816 =
                                            constructor_x64_roundss(ctx, v459, &RoundImm::RoundUp);
                                        let v1817 = constructor_output_xmm(ctx, v1816);
                                        // Rule at src/isa/x64/lower.isle line 3289.
                                        return Some(v1817);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1820 = C::libcall_1(ctx, &LibCall::CeilF32, v1819);
                                        let v1821 = constructor_output_reg(ctx, v1820);
                                        // Rule at src/isa/x64/lower.isle line 3292.
                                        return Some(v1821);
                                    }
                                    _ => {}
                                }
                            }
                            F64 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1822 =
                                            constructor_x64_roundsd(ctx, v459, &RoundImm::RoundUp);
                                        let v1823 = constructor_output_xmm(ctx, v1822);
                                        // Rule at src/isa/x64/lower.isle line 3295.
                                        return Some(v1823);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1825 = C::libcall_1(ctx, &LibCall::CeilF64, v1819);
                                        let v1826 = constructor_output_reg(ctx, v1825);
                                        // Rule at src/isa/x64/lower.isle line 3298.
                                        return Some(v1826);
                                    }
                                    _ => {}
                                }
                            }
                            F32X4 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1827 =
                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundUp);
                                    let v1828 = constructor_output_xmm(ctx, v1827);
                                    // Rule at src/isa/x64/lower.isle line 3301.
                                    return Some(v1828);
                                }
                            }
                            F64X2 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1829 =
                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundUp);
                                    let v1830 = constructor_output_xmm(ctx, v1829);
                                    // Rule at src/isa/x64/lower.isle line 3304.
                                    return Some(v1830);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Floor => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        match v529 {
                            F32 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1832 = constructor_x64_roundss(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundDown,
                                        );
                                        let v1833 = constructor_output_xmm(ctx, v1832);
                                        // Rule at src/isa/x64/lower.isle line 3309.
                                        return Some(v1833);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1835 = C::libcall_1(ctx, &LibCall::FloorF32, v1819);
                                        let v1836 = constructor_output_reg(ctx, v1835);
                                        // Rule at src/isa/x64/lower.isle line 3312.
                                        return Some(v1836);
                                    }
                                    _ => {}
                                }
                            }
                            F64 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1837 = constructor_x64_roundsd(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundDown,
                                        );
                                        let v1838 = constructor_output_xmm(ctx, v1837);
                                        // Rule at src/isa/x64/lower.isle line 3315.
                                        return Some(v1838);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1840 = C::libcall_1(ctx, &LibCall::FloorF64, v1819);
                                        let v1841 = constructor_output_reg(ctx, v1840);
                                        // Rule at src/isa/x64/lower.isle line 3318.
                                        return Some(v1841);
                                    }
                                    _ => {}
                                }
                            }
                            F32X4 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1842 =
                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundDown);
                                    let v1843 = constructor_output_xmm(ctx, v1842);
                                    // Rule at src/isa/x64/lower.isle line 3321.
                                    return Some(v1843);
                                }
                            }
                            F64X2 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1844 =
                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundDown);
                                    let v1845 = constructor_output_xmm(ctx, v1844);
                                    // Rule at src/isa/x64/lower.isle line 3324.
                                    return Some(v1845);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Trunc => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        match v529 {
                            F32 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1862 = constructor_x64_roundss(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundZero,
                                        );
                                        let v1863 = constructor_output_xmm(ctx, v1862);
                                        // Rule at src/isa/x64/lower.isle line 3349.
                                        return Some(v1863);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1865 = C::libcall_1(ctx, &LibCall::TruncF32, v1819);
                                        let v1866 = constructor_output_reg(ctx, v1865);
                                        // Rule at src/isa/x64/lower.isle line 3352.
                                        return Some(v1866);
                                    }
                                    _ => {}
                                }
                            }
                            F64 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1867 = constructor_x64_roundsd(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundZero,
                                        );
                                        let v1868 = constructor_output_xmm(ctx, v1867);
                                        // Rule at src/isa/x64/lower.isle line 3355.
                                        return Some(v1868);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1870 = C::libcall_1(ctx, &LibCall::TruncF64, v1819);
                                        let v1871 = constructor_output_reg(ctx, v1870);
                                        // Rule at src/isa/x64/lower.isle line 3358.
                                        return Some(v1871);
                                    }
                                    _ => {}
                                }
                            }
                            F32X4 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1872 =
                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundZero);
                                    let v1873 = constructor_output_xmm(ctx, v1872);
                                    // Rule at src/isa/x64/lower.isle line 3361.
                                    return Some(v1873);
                                }
                            }
                            F64X2 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1874 =
                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundZero);
                                    let v1875 = constructor_output_xmm(ctx, v1874);
                                    // Rule at src/isa/x64/lower.isle line 3364.
                                    return Some(v1875);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Nearest => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        match v529 {
                            F32 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1847 = constructor_x64_roundss(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundNearest,
                                        );
                                        let v1848 = constructor_output_xmm(ctx, v1847);
                                        // Rule at src/isa/x64/lower.isle line 3329.
                                        return Some(v1848);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1850 = C::libcall_1(ctx, &LibCall::NearestF32, v1819);
                                        let v1851 = constructor_output_reg(ctx, v1850);
                                        // Rule at src/isa/x64/lower.isle line 3332.
                                        return Some(v1851);
                                    }
                                    _ => {}
                                }
                            }
                            F64 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                match v1814 {
                                    true => {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1852 = constructor_x64_roundsd(
                                            ctx,
                                            v459,
                                            &RoundImm::RoundNearest,
                                        );
                                        let v1853 = constructor_output_xmm(ctx, v1852);
                                        // Rule at src/isa/x64/lower.isle line 3335.
                                        return Some(v1853);
                                    }
                                    false => {
                                        let v1819 = C::put_in_reg(ctx, v301);
                                        let v1855 = C::libcall_1(ctx, &LibCall::NearestF64, v1819);
                                        let v1856 = constructor_output_reg(ctx, v1855);
                                        // Rule at src/isa/x64/lower.isle line 3338.
                                        return Some(v1856);
                                    }
                                    _ => {}
                                }
                            }
                            F32X4 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1857 =
                                        constructor_x64_roundps(ctx, v459, &RoundImm::RoundNearest);
                                    let v1858 = constructor_output_xmm(ctx, v1857);
                                    // Rule at src/isa/x64/lower.isle line 3341.
                                    return Some(v1858);
                                }
                            }
                            F64X2 => {
                                let v3 = C::value_type(ctx, v2);
                                let v1814 = C::use_sse41(ctx, v3);
                                if v1814 == true {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1859 =
                                        constructor_x64_roundpd(ctx, v459, &RoundImm::RoundNearest);
                                    let v1860 = constructor_output_xmm(ctx, v1859);
                                    // Rule at src/isa/x64/lower.isle line 3344.
                                    return Some(v1860);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::IsNull => {
                    let v529 = C::value_type(ctx, v301);
                    if v529 == R64 {
                        let v302 = constructor_put_in_gpr(ctx, v301);
                        let v983 = &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0x0, v302);
                        let v984 = &constructor_x64_setcc(ctx, &CC::Z);
                        let v985 = constructor_with_flags(ctx, v983, v984);
                        let v986 = C::output(ctx, v985);
                        // Rule at src/isa/x64/lower.isle line 1957.
                        return Some(v986);
                    }
                }
                &Opcode::IsInvalid => {
                    let v529 = C::value_type(ctx, v301);
                    if v529 == R64 {
                        let v302 = constructor_put_in_gpr(ctx, v301);
                        let v988 =
                            &constructor_x64_cmp_imm(ctx, &OperandSize::Size64, 0xFFFFFFFF, v302);
                        let v984 = &constructor_x64_setcc(ctx, &CC::Z);
                        let v989 = constructor_with_flags(ctx, v988, v984);
                        let v990 = C::output(ctx, v989);
                        // Rule at src/isa/x64/lower.isle line 1965.
                        return Some(v990);
                    }
                }
                &Opcode::ScalarToVector => {
                    let v2109 = &C::sinkable_load(ctx, v301);
                    if let Some(v2110) = v2109 {
                        let v529 = C::value_type(ctx, v301);
                        let v2116 = C::ty_64(ctx, v529);
                        if let Some(v2117) = v2116 {
                            let v2113 = &C::sink_load(ctx, v2110);
                            let v2118 = constructor_x64_movsd_load(ctx, v2113);
                            let v2119 = constructor_output_xmm(ctx, v2118);
                            // Rule at src/isa/x64/lower.isle line 3768.
                            return Some(v2119);
                        }
                        let v2111 = C::ty_32(ctx, v529);
                        if let Some(v2112) = v2111 {
                            let v2113 = &C::sink_load(ctx, v2110);
                            let v2114 = constructor_x64_movss_load(ctx, v2113);
                            let v2115 = constructor_output_xmm(ctx, v2114);
                            // Rule at src/isa/x64/lower.isle line 3766.
                            return Some(v2115);
                        }
                    }
                    let v529 = C::value_type(ctx, v301);
                    let v1616 = C::ty_scalar_float(ctx, v529);
                    if let Some(v1617) = v1616 {
                        let v1009 = constructor_output_value(ctx, v301);
                        // Rule at src/isa/x64/lower.isle line 3756.
                        return Some(v1009);
                    }
                    let v302 = constructor_put_in_gpr(ctx, v301);
                    let v2107 = constructor_bitcast_gpr_to_xmm(ctx, v529, v302);
                    let v2108 = constructor_output_xmm(ctx, v2107);
                    // Rule at src/isa/x64/lower.isle line 3761.
                    return Some(v2108);
                }
                &Opcode::Bmask => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v305 = C::put_in_regs(ctx, v301);
                        let v3 = C::value_type(ctx, v2);
                        let v529 = C::value_type(ctx, v301);
                        let v530 = constructor_lower_bmask(ctx, v3, v529, v305);
                        let v531 = C::output(ctx, v530);
                        // Rule at src/isa/x64/lower.isle line 1154.
                        return Some(v531);
                    }
                }
                &Opcode::Ireduce => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        let v4 = C::fits_in_64(ctx, v3);
                        if let Some(v5) = v4 {
                            let v305 = C::put_in_regs(ctx, v301);
                            let v306 = constructor_value_regs_get_gpr(ctx, v305, 0x0);
                            let v1010 = constructor_output_gpr(ctx, v306);
                            // Rule at src/isa/x64/lower.isle line 2015.
                            return Some(v1010);
                        }
                        let v529 = C::value_type(ctx, v301);
                        if v3 == v529 {
                            let v1009 = constructor_output_value(ctx, v301);
                            // Rule at src/isa/x64/lower.isle line 2009.
                            return Some(v1009);
                        }
                    }
                }
                &Opcode::SwidenLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I8X16 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1728 = constructor_x64_pmovsxbw(ctx, v459);
                                    let v1729 = constructor_output_xmm(ctx, v1728);
                                    // Rule at src/isa/x64/lower.isle line 3154.
                                    return Some(v1729);
                                }
                            }
                            I32X4 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I16X8 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1730 = constructor_x64_pmovsxwd(ctx, v459);
                                    let v1731 = constructor_output_xmm(ctx, v1730);
                                    // Rule at src/isa/x64/lower.isle line 3157.
                                    return Some(v1731);
                                }
                            }
                            I64X2 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I32X4 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1732 = constructor_x64_pmovsxdq(ctx, v459);
                                    let v1733 = constructor_output_xmm(ctx, v1732);
                                    // Rule at src/isa/x64/lower.isle line 3160.
                                    return Some(v1733);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::SwidenHigh => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I8X16 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);
                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);
                                    let v1736 = constructor_x64_pmovsxbw(ctx, v1735);
                                    let v1737 = constructor_output_xmm(ctx, v1736);
                                    // Rule at src/isa/x64/lower.isle line 3165.
                                    return Some(v1737);
                                }
                            }
                            I32X4 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I16X8 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);
                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);
                                    let v1738 = constructor_x64_pmovsxwd(ctx, v1735);
                                    let v1739 = constructor_output_xmm(ctx, v1738);
                                    // Rule at src/isa/x64/lower.isle line 3169.
                                    return Some(v1739);
                                }
                            }
                            I64X2 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I32X4 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1740 = constructor_x64_pshufd(ctx, v459, 0xEE);
                                    let v1741 = &C::xmm_to_xmm_mem(ctx, v1740);
                                    let v1742 = constructor_x64_pmovsxdq(ctx, v1741);
                                    let v1743 = constructor_output_xmm(ctx, v1742);
                                    // Rule at src/isa/x64/lower.isle line 3173.
                                    return Some(v1743);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::UwidenLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I8X16 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1744 = constructor_x64_pmovzxbw(ctx, v459);
                                    let v1745 = constructor_output_xmm(ctx, v1744);
                                    // Rule at src/isa/x64/lower.isle line 3178.
                                    return Some(v1745);
                                }
                            }
                            I32X4 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I16X8 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1746 = constructor_x64_pmovzxwd(ctx, v459);
                                    let v1747 = constructor_output_xmm(ctx, v1746);
                                    // Rule at src/isa/x64/lower.isle line 3181.
                                    return Some(v1747);
                                }
                            }
                            I64X2 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I32X4 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1748 = constructor_x64_pmovzxdq(ctx, v459);
                                    let v1749 = constructor_output_xmm(ctx, v1748);
                                    // Rule at src/isa/x64/lower.isle line 3184.
                                    return Some(v1749);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::UwidenHigh => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I16X8 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I8X16 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);
                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);
                                    let v1750 = constructor_x64_pmovzxbw(ctx, v1735);
                                    let v1751 = constructor_output_xmm(ctx, v1750);
                                    // Rule at src/isa/x64/lower.isle line 3189.
                                    return Some(v1751);
                                }
                            }
                            I32X4 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I16X8 {
                                    let v469 = constructor_put_in_xmm(ctx, v301);
                                    let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                    let v1734 = constructor_x64_palignr(ctx, v469, v1075, 0x8);
                                    let v1735 = &C::xmm_to_xmm_mem(ctx, v1734);
                                    let v1752 = constructor_x64_pmovzxwd(ctx, v1735);
                                    let v1753 = constructor_output_xmm(ctx, v1752);
                                    // Rule at src/isa/x64/lower.isle line 3193.
                                    return Some(v1753);
                                }
                            }
                            I64X2 => {
                                let v529 = C::value_type(ctx, v301);
                                if v529 == I32X4 {
                                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                                    let v1740 = constructor_x64_pshufd(ctx, v459, 0xEE);
                                    let v1741 = &C::xmm_to_xmm_mem(ctx, v1740);
                                    let v1754 = constructor_x64_pmovzxdq(ctx, v1741);
                                    let v1755 = constructor_output_xmm(ctx, v1754);
                                    // Rule at src/isa/x64/lower.isle line 3197.
                                    return Some(v1755);
                                }
                            }
                            _ => {}
                        }
                    }
                }
                &Opcode::Uextend => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I64 => {
                                let v991 =
                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Zero);
                                let v996 = constructor_output_gpr(ctx, v991);
                                // Rule at src/isa/x64/lower.isle line 1978.
                                return Some(v996);
                            }
                            I128 => {
                                let v991 =
                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Zero);
                                let v992 = C::gpr_to_reg(ctx, v991);
                                let v993 = constructor_imm(ctx, I64, 0x0);
                                let v994 = C::value_regs(ctx, v992, v993);
                                let v995 = C::output(ctx, v994);
                                // Rule at src/isa/x64/lower.isle line 1974.
                                return Some(v995);
                            }
                            _ => {}
                        }
                        let v997 = C::fits_in_32(ctx, v3);
                        if let Some(v998) = v997 {
                            let v865 = constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Zero);
                            let v999 = constructor_output_gpr(ctx, v865);
                            // Rule at src/isa/x64/lower.isle line 1983.
                            return Some(v999);
                        }
                    }
                }
                &Opcode::Sextend => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            I64 => {
                                let v1000 =
                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Sign);
                                let v1006 = constructor_output_gpr(ctx, v1000);
                                // Rule at src/isa/x64/lower.isle line 1998.
                                return Some(v1006);
                            }
                            I128 => {
                                let v1000 =
                                    constructor_extend_to_gpr(ctx, v301, I64, &ExtendKind::Sign);
                                let v673 = Imm8Reg::Imm8 { imm: 0x3F };
                                let v674 = &C::imm8_reg_to_imm8_gpr(ctx, &v673);
                                let v1001 = constructor_x64_sar(ctx, I64, v1000, v674);
                                let v1002 = C::gpr_to_reg(ctx, v1000);
                                let v1003 = C::gpr_to_reg(ctx, v1001);
                                let v1004 = C::value_regs(ctx, v1002, v1003);
                                let v1005 = C::output(ctx, v1004);
                                // Rule at src/isa/x64/lower.isle line 1992.
                                return Some(v1005);
                            }
                            _ => {}
                        }
                        let v997 = C::fits_in_32(ctx, v3);
                        if let Some(v998) = v997 {
                            let v1007 =
                                constructor_extend_to_gpr(ctx, v301, I32, &ExtendKind::Sign);
                            let v1008 = constructor_output_gpr(ctx, v1007);
                            // Rule at src/isa/x64/lower.isle line 2003.
                            return Some(v1008);
                        }
                    }
                }
                &Opcode::Fpromote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F64 {
                            let v459 = &C::put_in_xmm_mem(ctx, v301);
                            let v1073 = constructor_x64_cvtss2sd(ctx, v459);
                            let v1074 = constructor_output_xmm(ctx, v1073);
                            // Rule at src/isa/x64/lower.isle line 2105.
                            return Some(v1074);
                        }
                    }
                }
                &Opcode::Fdemote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F32 {
                            let v459 = &C::put_in_xmm_mem(ctx, v301);
                            let v1078 = constructor_x64_cvtsd2ss(ctx, v459);
                            let v1079 = constructor_output_xmm(ctx, v1078);
                            // Rule at src/isa/x64/lower.isle line 2113.
                            return Some(v1079);
                        }
                    }
                }
                &Opcode::Fvdemote => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F32X4 {
                            let v459 = &C::put_in_xmm_mem(ctx, v301);
                            let v1080 = constructor_x64_cvtpd2ps(ctx, v459);
                            let v1081 = constructor_output_xmm(ctx, v1080);
                            // Rule at src/isa/x64/lower.isle line 2117.
                            return Some(v1081);
                        }
                    }
                }
                &Opcode::FvpromoteLow => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == F64X2 {
                            let v469 = constructor_put_in_xmm(ctx, v301);
                            let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                            let v1076 = constructor_x64_cvtps2pd(ctx, v1075);
                            let v1077 = constructor_output_xmm(ctx, v1076);
                            // Rule at src/isa/x64/lower.isle line 2109.
                            return Some(v1077);
                        }
                    }
                }
                &Opcode::FcvtToUint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        let v1616 = C::ty_scalar_float(ctx, v529);
                        if let Some(v1617) = v1616 {
                            let v3 = C::value_type(ctx, v2);
                            let v1618 = constructor_cvt_float_to_uint_seq(ctx, v3, v301, false);
                            let v1619 = constructor_output_gpr(ctx, v1618);
                            // Rule at src/isa/x64/lower.isle line 2965.
                            return Some(v1619);
                        }
                    }
                }
                &Opcode::FcvtToSint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v529 = C::value_type(ctx, v301);
                        let v1616 = C::ty_scalar_float(ctx, v529);
                        if let Some(v1617) = v1616 {
                            let v3 = C::value_type(ctx, v2);
                            let v1622 = constructor_cvt_float_to_sint_seq(ctx, v3, v301, false);
                            let v1623 = constructor_output_gpr(ctx, v1622);
                            // Rule at src/isa/x64/lower.isle line 2971.
                            return Some(v1623);
                        }
                    }
                }
                &Opcode::FcvtToUintSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v529 = C::value_type(ctx, v301);
                            if v529 == F32X4 {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v1640 = constructor_xmm_zero(ctx, F32X4);
                                let v1641 = &C::xmm_to_xmm_mem(ctx, v1640);
                                let v1642 = constructor_x64_maxps(ctx, v469, v1641);
                                let v1643 = &C::xmm_to_xmm_mem(ctx, v1640);
                                let v1644 = constructor_x64_pcmpeqd(ctx, v1640, v1643);
                                let v1645 = &C::xmi_imm(ctx, 0x1);
                                let v1646 = constructor_x64_psrld(ctx, v1644, v1645);
                                let v1647 = &C::xmm_to_xmm_mem(ctx, v1646);
                                let v1648 = constructor_x64_cvtdq2ps(ctx, v1647);
                                let v1649 = &C::xmm_to_xmm_mem(ctx, v1642);
                                let v1650 = constructor_x64_cvttps2dq(ctx, v1649);
                                let v1651 = &C::xmm_to_xmm_mem(ctx, v1648);
                                let v1652 = constructor_x64_subps(ctx, v1642, v1651);
                                let v1653 = &C::xmm_to_xmm_mem(ctx, v1652);
                                let v1654 = constructor_x64_cmpps(
                                    ctx,
                                    v1648,
                                    v1653,
                                    &FcmpImm::LessThanOrEqual,
                                );
                                let v1655 = &C::xmm_to_xmm_mem(ctx, v1652);
                                let v1656 = constructor_x64_cvttps2dq(ctx, v1655);
                                let v1657 = &C::xmm_to_xmm_mem(ctx, v1654);
                                let v1658 = constructor_x64_pxor(ctx, v1656, v1657);
                                let v1659 = constructor_xmm_zero(ctx, I32X4);
                                let v1660 = &C::xmm_to_xmm_mem(ctx, v1659);
                                let v1661 = constructor_x64_pmaxsd(ctx, v1658, v1660);
                                let v1662 = &C::xmm_to_xmm_mem(ctx, v1650);
                                let v1663 = constructor_x64_paddd(ctx, v1661, v1662);
                                let v1664 = constructor_output_xmm(ctx, v1663);
                                // Rule at src/isa/x64/lower.isle line 3049.
                                return Some(v1664);
                            }
                        }
                        let v529 = C::value_type(ctx, v301);
                        let v1616 = C::ty_scalar_float(ctx, v529);
                        if let Some(v1617) = v1616 {
                            let v1620 = constructor_cvt_float_to_uint_seq(ctx, v3, v301, true);
                            let v1621 = constructor_output_gpr(ctx, v1620);
                            // Rule at src/isa/x64/lower.isle line 2968.
                            return Some(v1621);
                        }
                    }
                }
                &Opcode::FcvtToSintSat => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v529 = C::value_type(ctx, v301);
                            if v529 == F32X4 {
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v1075 = &C::xmm_to_xmm_mem(ctx, v469);
                                let v1626 =
                                    constructor_x64_cmpps(ctx, v469, v1075, &FcmpImm::Equal);
                                let v1627 = &C::xmm_to_xmm_mem(ctx, v1626);
                                let v1628 = constructor_x64_andps(ctx, v469, v1627);
                                let v1629 = &C::xmm_to_xmm_mem(ctx, v1628);
                                let v1630 = constructor_x64_pxor(ctx, v1626, v1629);
                                let v1631 = &C::xmm_to_xmm_mem(ctx, v1628);
                                let v1632 = constructor_x64_cvttps2dq(ctx, v1631);
                                let v1633 = &C::xmm_to_xmm_mem(ctx, v1630);
                                let v1634 = constructor_x64_pand(ctx, v1632, v1633);
                                let v1635 = &C::xmi_imm(ctx, 0x1F);
                                let v1636 = constructor_x64_psrad(ctx, v1634, v1635);
                                let v1637 = &C::xmm_to_xmm_mem(ctx, v1632);
                                let v1638 = constructor_x64_pxor(ctx, v1636, v1637);
                                let v1639 = constructor_output_xmm(ctx, v1638);
                                // Rule at src/isa/x64/lower.isle line 2978.
                                return Some(v1639);
                            }
                        }
                        let v529 = C::value_type(ctx, v301);
                        let v1616 = C::ty_scalar_float(ctx, v529);
                        if let Some(v1617) = v1616 {
                            let v1624 = constructor_cvt_float_to_sint_seq(ctx, v3, v301, true);
                            let v1625 = constructor_output_gpr(ctx, v1624);
                            // Rule at src/isa/x64/lower.isle line 2974.
                            return Some(v1625);
                        }
                    }
                }
                &Opcode::X86Cvtt2dq => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        if v3 == I32X4 {
                            let v529 = C::value_type(ctx, v301);
                            if v529 == F32X4 {
                                let v459 = &C::put_in_xmm_mem(ctx, v301);
                                let v1665 = constructor_x64_cvttps2dq(ctx, v459);
                                let v1666 = constructor_output_xmm(ctx, v1665);
                                // Rule at src/isa/x64/lower.isle line 3096.
                                return Some(v1666);
                            }
                        }
                    }
                }
                &Opcode::FcvtFromUint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v529 = C::value_type(ctx, v301);
                                let v1571 = C::fits_in_32(ctx, v529);
                                if let Some(v1572) = v1571 {
                                    let v1573 = C::ty_int(ctx, v1572);
                                    if let Some(v1574) = v1573 {
                                        let v991 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I64,
                                            &ExtendKind::Zero,
                                        );
                                        let v1575 = &C::gpr_to_gpr_mem(ctx, v991);
                                        let v1576 = constructor_x64_cvtsi2ss(ctx, I64, v1575);
                                        let v1577 = constructor_output_xmm(ctx, v1576);
                                        // Rule at src/isa/x64/lower.isle line 2893.
                                        return Some(v1577);
                                    }
                                }
                            }
                            F64 => {
                                let v529 = C::value_type(ctx, v301);
                                let v1571 = C::fits_in_32(ctx, v529);
                                if let Some(v1572) = v1571 {
                                    let v1573 = C::ty_int(ctx, v1572);
                                    if let Some(v1574) = v1573 {
                                        let v991 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I64,
                                            &ExtendKind::Zero,
                                        );
                                        let v1575 = &C::gpr_to_gpr_mem(ctx, v991);
                                        let v1578 = constructor_x64_cvtsi2sd(ctx, I64, v1575);
                                        let v1579 = constructor_output_xmm(ctx, v1578);
                                        // Rule at src/isa/x64/lower.isle line 2896.
                                        return Some(v1579);
                                    }
                                }
                            }
                            F32X4 => {
                                let v363 = C::avx512vl_enabled(ctx, v3);
                                if v363 == true {
                                    let v466 = C::avx512f_enabled(ctx, v3);
                                    if v466 == true {
                                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                                        let v1596 = constructor_x64_vcvtudq2ps(ctx, v459);
                                        let v1597 = constructor_output_xmm(ctx, v1596);
                                        // Rule at src/isa/x64/lower.isle line 2914.
                                        return Some(v1597);
                                    }
                                }
                                let v469 = constructor_put_in_xmm(ctx, v301);
                                let v1599 = &C::xmi_imm(ctx, 0x10);
                                let v1600 = constructor_x64_pslld(ctx, v469, v1599);
                                let v1601 = &C::xmi_imm(ctx, 0x10);
                                let v1602 = constructor_x64_psrld(ctx, v1600, v1601);
                                let v1603 = &C::xmm_to_xmm_mem(ctx, v1602);
                                let v1604 = constructor_x64_psubd(ctx, v469, v1603);
                                let v1605 = &C::xmm_to_xmm_mem(ctx, v1602);
                                let v1606 = constructor_x64_cvtdq2ps(ctx, v1605);
                                let v1607 = &C::xmi_imm(ctx, 0x1);
                                let v1608 = constructor_x64_psrld(ctx, v1604, v1607);
                                let v1609 = &C::xmm_to_xmm_mem(ctx, v1608);
                                let v1610 = constructor_x64_cvtdq2ps(ctx, v1609);
                                let v1611 = &C::xmm_to_xmm_mem(ctx, v1610);
                                let v1612 = constructor_x64_addps(ctx, v1610, v1611);
                                let v1613 = &C::xmm_to_xmm_mem(ctx, v1606);
                                let v1614 = constructor_x64_addps(ctx, v1612, v1613);
                                let v1615 = constructor_output_xmm(ctx, v1614);
                                // Rule at src/isa/x64/lower.isle line 2941.
                                return Some(v1615);
                            }
                            F64X2 => {
                                let v1582 = C::def_inst(ctx, v301);
                                if let Some(v1583) = v1582 {
                                    let v1584 = &C::inst_data(ctx, v1583);
                                    if let &InstructionData::Unary {
                                        opcode: ref v1585,
                                        arg: v1586,
                                    } = v1584
                                    {
                                        if let &Opcode::UwidenLow = v1585 {
                                            let v1587 = C::value_type(ctx, v1586);
                                            if v1587 == I32X4 {
                                                let v1588 = C::fcvt_uint_mask_const(ctx);
                                                let v1589 =
                                                    &constructor_const_to_xmm_mem(ctx, v1588);
                                                let v1590 = constructor_put_in_xmm(ctx, v1586);
                                                let v1591 =
                                                    constructor_x64_unpcklps(ctx, v1590, v1589);
                                                let v1592 = C::fcvt_uint_mask_high_const(ctx);
                                                let v1593 =
                                                    &constructor_const_to_xmm_mem(ctx, v1592);
                                                let v1594 =
                                                    constructor_x64_subpd(ctx, v1591, v1593);
                                                let v1595 = constructor_output_xmm(ctx, v1594);
                                                // Rule at src/isa/x64/lower.isle line 2906.
                                                return Some(v1595);
                                            }
                                        }
                                    }
                                }
                            }
                            _ => {}
                        }
                        let v529 = C::value_type(ctx, v301);
                        if v529 == I64 {
                            let v302 = constructor_put_in_gpr(ctx, v301);
                            let v1580 = constructor_cvt_u64_to_float_seq(ctx, v3, v302);
                            let v1581 = constructor_output_xmm(ctx, v1580);
                            // Rule at src/isa/x64/lower.isle line 2899.
                            return Some(v1581);
                        }
                    }
                }
                &Opcode::FcvtFromSint => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v3 = C::value_type(ctx, v2);
                        match v3 {
                            F32 => {
                                let v529 = C::value_type(ctx, v301);
                                match v529 {
                                    I8 => {
                                        let v1007 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I32,
                                            &ExtendKind::Sign,
                                        );
                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);
                                        let v1554 = constructor_x64_cvtsi2ss(ctx, I32, v1553);
                                        let v1555 = constructor_output_xmm(ctx, v1554);
                                        // Rule at src/isa/x64/lower.isle line 2865.
                                        return Some(v1555);
                                    }
                                    I16 => {
                                        let v1007 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I32,
                                            &ExtendKind::Sign,
                                        );
                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);
                                        let v1554 = constructor_x64_cvtsi2ss(ctx, I32, v1553);
                                        let v1555 = constructor_output_xmm(ctx, v1554);
                                        // Rule at src/isa/x64/lower.isle line 2868.
                                        return Some(v1555);
                                    }
                                    _ => {}
                                }
                                let v1556 = C::ty_int(ctx, v529);
                                if let Some(v1557) = v1556 {
                                    let v1558 = C::fits_in_64(ctx, v1557);
                                    if let Some(v1559) = v1558 {
                                        let v1560 = &constructor_put_in_gpr_mem(ctx, v301);
                                        let v1561 = constructor_x64_cvtsi2ss(ctx, v1559, v1560);
                                        let v1562 = constructor_output_xmm(ctx, v1561);
                                        // Rule at src/isa/x64/lower.isle line 2871.
                                        return Some(v1562);
                                    }
                                }
                            }
                            F64 => {
                                let v529 = C::value_type(ctx, v301);
                                match v529 {
                                    I8 => {
                                        let v1007 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I32,
                                            &ExtendKind::Sign,
                                        );
                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);
                                        let v1563 = constructor_x64_cvtsi2sd(ctx, I32, v1553);
                                        let v1564 = constructor_output_xmm(ctx, v1563);
                                        // Rule at src/isa/x64/lower.isle line 2874.
                                        return Some(v1564);
                                    }
                                    I16 => {
                                        let v1007 = constructor_extend_to_gpr(
                                            ctx,
                                            v301,
                                            I32,
                                            &ExtendKind::Sign,
                                        );
                                        let v1553 = &C::gpr_to_gpr_mem(ctx, v1007);
                                        let v1563 = constructor_x64_cvtsi2sd(ctx, I32, v1553);
                                        let v1564 = constructor_output_xmm(ctx, v1563);
                                        // Rule at src/isa/x64/lower.isle line 2877.
                                        return Some(v1564);
                                    }
                                    _ => {}
                                }
                                let v1556 = C::ty_int(ctx, v529);
                                if let Some(v1557) = v1556 {
                                    let v1558 = C::fits_in_64(ctx, v1557);
                                    if let Some(v1559) = v1558 {
                                        let v1560 = &constructor_put_in_gpr_mem(ctx, v301);
                                        let v1565 = constructor_x64_cvtsi2sd(ctx, v1559, v1560);
                                        let v1566 = constructor_output_xmm(ctx, v1565);
                                        // Rule at src/isa/x64/lower.isle line 2880.
                                        return Some(v1566);
                                    }
                                }
                            }
                            _ => {}
                        }
                    }
                    let v529 = C::value_type(ctx, v301);
                    if v529 == I32X4 {
                        let v459 = &C::put_in_xmm_mem(ctx, v301);
                        let v1567 = constructor_x64_cvtdq2ps(ctx, v459);
                        let v1568 = constructor_output_xmm(ctx, v1567);
                        // Rule at src/isa/x64/lower.isle line 2883.
                        return Some(v1568);
                    }
                }
                &Opcode::FcvtLowFromSint => {
                    let v459 = &C::put_in_xmm_mem(ctx, v301);
                    let v1569 = constructor_x64_cvtdq2pd(ctx, v459);
                    let v1570 = constructor_output_xmm(ctx, v1569);
                    // Rule at src/isa/x64/lower.isle line 2888.
                    return Some(v1570);
                }
                &Opcode::Isplit => {
                    let v529 = C::value_type(ctx, v301);
                    if v529 == I128 {
                        let v305 = C::put_in_regs(ctx, v301);
                        let v2211 = C::value_regs_get(ctx, v305, 0x0);
                        let v2212 = C::value_regs_get(ctx, v305, 0x1);
                        let v2213 = C::value_reg(ctx, v2211);
                        let v2214 = C::value_reg(ctx, v2212);
                        let v2215 = C::output_pair(ctx, v2213, v2214);
                        // Rule at src/isa/x64/lower.isle line 3910.
                        return Some(v2215);
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryConst {
            opcode: ref v1962,
            constant_handle: v1963,
        } => {
            if let &Opcode::Vconst = v1962 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v1964 = C::const_to_vconst(ctx, v1963);
                    let v3 = C::value_type(ctx, v2);
                    let v1965 = constructor_x64_xmm_load_const(ctx, v3, v1964);
                    let v1966 = constructor_output_xmm(ctx, v1965);
                    // Rule at src/isa/x64/lower.isle line 3548.
                    return Some(v1966);
                }
            }
        }
        &InstructionData::UnaryGlobalValue {
            opcode: ref v1448,
            global_value: v1449,
        } => {
            match v1448 {
                &Opcode::SymbolValue => {
                    let v1450 = C::symbol_value_data(ctx, v1449);
                    if let Some(v1451) = v1450 {
                        let v1455 = constructor_load_ext_name(ctx, v1451.0, v1451.2);
                        let v1456 = constructor_output_reg(ctx, v1455);
                        // Rule at src/isa/x64/lower.isle line 2718.
                        return Some(v1456);
                    }
                }
                &Opcode::TlsValue => {
                    let v1 = C::first_result(ctx, arg0);
                    if let Some(v2) = v1 {
                        let v1450 = C::symbol_value_data(ctx, v1449);
                        if let Some(v1451) = v1450 {
                            let v3 = C::value_type(ctx, v2);
                            let v2216 = &C::tls_model(ctx, v3);
                            match v2216 {
                                &TlsModel::ElfGd => {
                                    let v2217 = constructor_elf_tls_get_addr(ctx, v1451.0);
                                    let v2218 = constructor_output_gpr(ctx, v2217);
                                    // Rule at src/isa/x64/lower.isle line 3918.
                                    return Some(v2218);
                                }
                                &TlsModel::Macho => {
                                    let v2219 = constructor_macho_tls_get_addr(ctx, v1451.0);
                                    let v2220 = constructor_output_gpr(ctx, v2219);
                                    // Rule at src/isa/x64/lower.isle line 3921.
                                    return Some(v2220);
                                }
                                &TlsModel::Coff => {
                                    let v2221 = constructor_coff_tls_get_addr(ctx, v1451.0);
                                    let v2222 = constructor_output_gpr(ctx, v2221);
                                    // Rule at src/isa/x64/lower.isle line 3924.
                                    return Some(v2222);
                                }
                                _ => {}
                            }
                        }
                    }
                }
                _ => {}
            }
        }
        &InstructionData::UnaryIeee32 {
            opcode: ref v18,
            imm: v19,
        } => {
            if let &Opcode::F32const = v18 {
                let v20 = C::u32_from_ieee32(ctx, v19);
                let v22 = C::u32_as_u64(ctx, v20);
                let v23 = constructor_imm(ctx, F32, v22);
                let v24 = constructor_output_reg(ctx, v23);
                // Rule at src/isa/x64/lower.isle line 27.
                return Some(v24);
            }
        }
        &InstructionData::UnaryIeee64 {
            opcode: ref v25,
            imm: v26,
        } => {
            if let &Opcode::F64const = v25 {
                let v27 = C::u64_from_ieee64(ctx, v26);
                let v29 = constructor_imm(ctx, F64, v27);
                let v30 = constructor_output_reg(ctx, v29);
                // Rule at src/isa/x64/lower.isle line 32.
                return Some(v30);
            }
        }
        &InstructionData::UnaryImm {
            opcode: ref v7,
            imm: v8,
        } => {
            if let &Opcode::Iconst = v7 {
                let v1 = C::first_result(ctx, arg0);
                if let Some(v2) = v1 {
                    let v3 = C::value_type(ctx, v2);
                    if v3 == I128 {
                        let v9 = C::u64_from_imm64(ctx, v8);
                        let v13 = constructor_imm(ctx, I64, v9);
                        let v15 = constructor_imm(ctx, I64, 0x0);
                        let v16 = C::value_regs(ctx, v13, v15);
                        let v17 = C::output(ctx, v16);
                        // Rule at src/isa/x64/lower.isle line 20.
                        return Some(v17);
                    }
                    let v4 = C::fits_in_64(ctx, v3);
                    if let Some(v5) = v4 {
                        let v9 = C::u64_from_imm64(ctx, v8);
                        let v10 = constructor_imm(ctx, v5, v9);
                        let v11 = constructor_output_reg(ctx, v10);
                        // Rule at src/isa/x64/lower.isle line 15.
                        return Some(v11);
                    }
                }
            }
        }
        _ => {}
    }
    None
}
// Generated as internal constructor for term lower_branch.
pub fn constructor_lower_branch<C: Context>(
    ctx: &mut C,
    arg0: Inst,
    arg1: &MachLabelSlice,
) -> Option<Unit> {
    let v1 = &C::inst_data(ctx, arg0);
    match v1 {
        &InstructionData::BranchTable {
            opcode: ref v55,
            arg: v56,
            table: v57,
        } => {
            if let &Opcode::BrTable = v55 {
                let v59 = C::jump_table_targets(ctx, arg1);
                if let Some(v60) = v59 {
                    let v58 = C::value_type(ctx, v56);
                    let v63 = &C::raw_operand_size_of_type(ctx, v58);
                    let v64 = C::jump_table_size(ctx, &v60.1);
                    let v65 = C::u32_as_u64(ctx, v64);
                    let v66 = constructor_imm(ctx, v58, v65);
                    let v69 = constructor_extend_to_gpr(ctx, v56, I64, &ExtendKind::Zero);
                    let v70 = &constructor_reg_to_gpr_mem_imm(ctx, v66);
                    let v71 = &constructor_x64_cmp(ctx, v63, v70, v69);
                    let v73 = &C::gpr_to_gpr_mem(ctx, v69);
                    let v74 = C::gpr_new(ctx, v66);
                    let v75 = &constructor_cmove(ctx, v58, &CC::B, v73, v74);
                    let v76 = constructor_with_flags_reg(ctx, v71, v75);
                    let v77 = C::gpr_new(ctx, v76);
                    let v78 = &constructor_jmp_table_seq(ctx, v58, v77, v60.0, &v60.1);
                    let v79 = constructor_emit_side_effect(ctx, v78);
                    // Rule at src/isa/x64/lower.isle line 2839.
                    return Some(v79);
                }
            }
        }
        &InstructionData::Brif {
            opcode: ref v9,
            arg: v10,
            blocks: ref v11,
        } => {
            if let &Opcode::Brif = v9 {
                let v26 = C::two_targets(ctx, arg1);
                if let Some(v27) = v26 {
                    let v12 = C::maybe_uextend(ctx, v10);
                    if let Some(v13) = v12 {
                        let v14 = C::def_inst(ctx, v13);
                        if let Some(v15) = v14 {
                            let v16 = &C::inst_data(ctx, v15);
                            match v16 {
                                &InstructionData::FloatCompare {
                                    opcode: ref v33,
                                    args: ref v34,
                                    cond: ref v35,
                                } => {
                                    if let &Opcode::Fcmp = v33 {
                                        let v36 = C::unpack_value_array_2(ctx, v34);
                                        let v39 = &constructor_emit_fcmp(ctx, v35, v36.0, v36.1);
                                        let v40 =
                                            &constructor_jmp_cond_fcmp(ctx, v39, v27.0, v27.1);
                                        let v41 = constructor_emit_side_effect(ctx, v40);
                                        // Rule at src/isa/x64/lower.isle line 2800.
                                        return Some(v41);
                                    }
                                }
                                &InstructionData::IntCompare {
                                    opcode: ref v17,
                                    args: ref v18,
                                    cond: ref v19,
                                } => {
                                    if let &Opcode::Icmp = v17 {
                                        let v20 = C::unpack_value_array_2(ctx, v18);
                                        let v30 = &constructor_emit_cmp(ctx, v19, v20.0, v20.1);
                                        let v31 =
                                            &constructor_jmp_cond_icmp(ctx, v30, v27.0, v27.1);
                                        let v32 = constructor_emit_side_effect(ctx, v31);
                                        // Rule at src/isa/x64/lower.isle line 2797.
                                        return Some(v32);
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                    let v42 = C::value_type(ctx, v10);
                    if v42 == I128 {
                        let v44 = C::put_in_regs(ctx, v10);
                        let v45 = &constructor_cmp_zero_i128(ctx, &CC::Z, v44);
                        let v46 = &constructor_jmp_cond_icmp(ctx, v45, v27.0, v27.1);
                        let v47 = constructor_emit_side_effect(ctx, v46);
                        // Rule at src/isa/x64/lower.isle line 2803.
                        return Some(v47);
                    }
                    let v48 = C::ty_int_bool_or_ref(ctx, v42);
                    if let Some(v49) = v48 {
                        let v50 = &constructor_cmp_zero_int_bool_ref(ctx, v10);
                        let v52 = &constructor_jmp_cond(ctx, &CC::NZ, v27.0, v27.1);
                        let v53 = &constructor_with_flags_side_effect(ctx, v50, v52);
                        let v54 = constructor_emit_side_effect(ctx, v53);
                        // Rule at src/isa/x64/lower.isle line 2807.
                        return Some(v54);
                    }
                }
            }
        }
        &InstructionData::Jump {
            opcode: ref v2,
            destination: v3,
        } => {
            if let &Opcode::Jump = v2 {
                let v5 = C::single_target(ctx, arg1);
                if let Some(v6) = v5 {
                    let v7 = &constructor_jmp_known(ctx, v6);
                    let v8 = constructor_emit_side_effect(ctx, v7);
                    // Rule at src/isa/x64/lower.isle line 2792.
                    return Some(v8);
                }
            }
        }
        _ => {}
    }
    None
}
// Generated as internal constructor for term sse_and.
pub fn constructor_sse_and<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 225.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 226.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_andps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 223.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 224.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pand(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 227.
        return v9;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "sse_and", "src/isa/x64/lower.isle line 222"
    )
}
// Generated as internal constructor for term sse_and_not.
pub fn constructor_sse_and_not<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &XmmMem,
) -> Xmm {
    match arg0 {
        F32X4 => {
            let v3 = constructor_x64_andnps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 250.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_andnpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 251.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_pandn(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 252.
        return v9;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "sse_and_not", "src/isa/x64/lower.isle line 249"
    )
}
// Generated as internal constructor for term sse_or.
pub fn constructor_sse_or<C: Context>(ctx: &mut C, arg0: Type, arg1: Xmm, arg2: &XmmMem) -> Xmm {
    match arg0 {
        F32 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 305.
            return v3;
        }
        F64 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 306.
            return v4;
        }
        F32X4 => {
            let v3 = constructor_x64_orps(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 303.
            return v3;
        }
        F64X2 => {
            let v4 = constructor_x64_orpd(ctx, arg1, arg2);
            // Rule at src/isa/x64/lower.isle line 304.
            return v4;
        }
        _ => {}
    }
    let v5 = C::multi_lane(ctx, arg0);
    if let Some(v6) = v5 {
        let v9 = constructor_x64_por(ctx, arg1, arg2);
        // Rule at src/isa/x64/lower.isle line 307.
        return v9;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "sse_or", "src/isa/x64/lower.isle line 302"
    )
}
// Generated as internal constructor for term or_i128.
pub fn constructor_or_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: ValueRegs) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);
    let v6 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);
    let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);
    let v9 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v10 = constructor_x64_or(ctx, I64, v3, v9);
    let v11 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v12 = constructor_x64_or(ctx, I64, v5, v11);
    let v13 = constructor_value_gprs(ctx, v10, v12);
    // Rule at src/isa/x64/lower.isle line 316.
    return v13;
}
// Generated as internal constructor for term shl_i128.
pub fn constructor_shl_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);
    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shl(ctx, I64, v3, v7);
    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_shl(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shr(ctx, I64, v3, v16);
    let v19 = constructor_imm(ctx, I64, 0x0);
    let v20 = C::gpr_new(ctx, v19);
    let v23 = RegMemImm::Imm { simm32: 0x7F };
    let v24 = &C::gpr_mem_imm_new(ctx, &v23);
    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);
    let v27 = &C::gpr_to_gpr_mem(ctx, v20);
    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);
    let v29 = constructor_with_flags_reg(ctx, v25, v28);
    let v30 = C::gpr_new(ctx, v29);
    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v10);
    let v32 = constructor_x64_or(ctx, I64, v30, v31);
    let v34 = RegMemImm::Imm { simm32: 0x40 };
    let v35 = &C::gpr_mem_imm_new(ctx, &v34);
    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);
    let v37 = &C::gpr_to_gpr_mem(ctx, v8);
    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v20);
    let v39 = &C::gpr_to_gpr_mem(ctx, v32);
    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v8);
    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);
    let v42 = constructor_with_flags(ctx, v36, v41);
    // Rule at src/isa/x64/lower.isle line 379.
    return v42;
}
// Generated as internal constructor for term ishl_i8x16_mask.
pub fn constructor_ishl_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {
    match arg0 {
        &RegMemImm::Reg { reg: v3 } => {
            let v4 = &C::ishl_i8x16_mask_table(ctx);
            let v6 = constructor_x64_lea(ctx, I64, v4);
            let v7 = C::gpr_new(ctx, v3);
            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);
            let v10 = constructor_x64_shl(ctx, I64, v7, v9);
            let v13 = C::mem_flags_trusted(ctx);
            let v14 = Amode::ImmRegRegShift {
                simm32: 0x0,
                base: v6,
                index: v10,
                shift: 0x0,
                flags: v13,
            };
            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);
            // Rule at src/isa/x64/lower.isle line 453.
            return v15.clone();
        }
        &RegMemImm::Mem { addr: ref v16 } => {
            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);
            let v19 = RegMemImm::Reg { reg: v18 };
            let v20 = &constructor_ishl_i8x16_mask(ctx, &v19);
            // Rule at src/isa/x64/lower.isle line 464.
            return v20.clone();
        }
        &RegMemImm::Imm { simm32: v1 } => {
            let v2 = &C::ishl_i8x16_mask_for_const(ctx, v1);
            // Rule at src/isa/x64/lower.isle line 444.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "ishl_i8x16_mask", "src/isa/x64/lower.isle line 438"
    )
}
// Generated as internal constructor for term shr_i128.
pub fn constructor_shr_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);
    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shr(ctx, I64, v3, v7);
    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_shr(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shl(ctx, I64, v5, v16);
    let v19 = constructor_imm(ctx, I64, 0x0);
    let v20 = C::gpr_new(ctx, v19);
    let v23 = RegMemImm::Imm { simm32: 0x7F };
    let v24 = &C::gpr_mem_imm_new(ctx, &v23);
    let v25 = &constructor_x64_test(ctx, &OperandSize::Size64, v24, arg1);
    let v27 = &C::gpr_to_gpr_mem(ctx, v20);
    let v28 = &constructor_cmove(ctx, I64, &CC::Z, v27, v17);
    let v29 = constructor_with_flags_reg(ctx, v25, v28);
    let v30 = C::gpr_new(ctx, v29);
    let v31 = &C::gpr_to_gpr_mem_imm(ctx, v8);
    let v32 = constructor_x64_or(ctx, I64, v30, v31);
    let v34 = RegMemImm::Imm { simm32: 0x40 };
    let v35 = &C::gpr_mem_imm_new(ctx, &v34);
    let v36 = &constructor_x64_test(ctx, &OperandSize::Size64, v35, arg1);
    let v37 = &C::gpr_to_gpr_mem(ctx, v32);
    let v38 = &constructor_cmove(ctx, I64, &CC::Z, v37, v10);
    let v39 = &C::gpr_to_gpr_mem(ctx, v10);
    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v20);
    let v41 = &constructor_consumes_flags_concat(ctx, v38, v40);
    let v42 = constructor_with_flags(ctx, v36, v41);
    // Rule at src/isa/x64/lower.isle line 489.
    return v42;
}
// Generated as internal constructor for term ushr_i8x16_mask.
pub fn constructor_ushr_i8x16_mask<C: Context>(ctx: &mut C, arg0: &RegMemImm) -> SyntheticAmode {
    match arg0 {
        &RegMemImm::Reg { reg: v3 } => {
            let v4 = &C::ushr_i8x16_mask_table(ctx);
            let v6 = constructor_x64_lea(ctx, I64, v4);
            let v7 = C::gpr_new(ctx, v3);
            let v9 = &C::imm8_to_imm8_gpr(ctx, 0x4);
            let v10 = constructor_x64_shl(ctx, I64, v7, v9);
            let v13 = C::mem_flags_trusted(ctx);
            let v14 = Amode::ImmRegRegShift {
                simm32: 0x0,
                base: v6,
                index: v10,
                shift: 0x0,
                flags: v13,
            };
            let v15 = &C::amode_to_synthetic_amode(ctx, &v14);
            // Rule at src/isa/x64/lower.isle line 558.
            return v15.clone();
        }
        &RegMemImm::Mem { addr: ref v16 } => {
            let v18 = constructor_x64_load(ctx, I64, v16, &ExtKind::None);
            let v19 = RegMemImm::Reg { reg: v18 };
            let v20 = &constructor_ushr_i8x16_mask(ctx, &v19);
            // Rule at src/isa/x64/lower.isle line 570.
            return v20.clone();
        }
        &RegMemImm::Imm { simm32: v1 } => {
            let v2 = &C::ushr_i8x16_mask_for_const(ctx, v1);
            // Rule at src/isa/x64/lower.isle line 549.
            return v2.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "ushr_i8x16_mask", "src/isa/x64/lower.isle line 543"
    )
}
// Generated as internal constructor for term mask_xmm_shift.
pub fn constructor_mask_xmm_shift<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> RegMemImm {
    let v10 = C::def_inst(ctx, arg1);
    if let Some(v11) = v10 {
        let v12 = &C::inst_data(ctx, v11);
        if let &InstructionData::UnaryImm {
            opcode: ref v13,
            imm: v14,
        } = v12
        {
            if let &Opcode::Iconst = v13 {
                let v15 = C::shift_amount_masked(ctx, arg0, v14);
                let v16 = RegMemImm::Imm { simm32: v15 };
                // Rule at src/isa/x64/lower.isle line 587.
                return v16;
            }
        }
    }
    let v3 = constructor_put_in_gpr(ctx, arg1);
    let v4 = C::shift_mask(ctx, arg0);
    let v5 = RegMemImm::Imm { simm32: v4 };
    let v6 = &C::gpr_mem_imm_new(ctx, &v5);
    let v7 = constructor_x64_and(ctx, I64, v3, v6);
    let v8 = C::gpr_to_reg(ctx, v7);
    let v9 = &C::reg_to_reg_mem_imm(ctx, v8);
    // Rule at src/isa/x64/lower.isle line 585.
    return v9.clone();
}
// Generated as internal constructor for term sar_i128.
pub fn constructor_sar_i128<C: Context>(ctx: &mut C, arg0: ValueRegs, arg1: Gpr) -> ValueRegs {
    let v3 = constructor_value_regs_get_gpr(ctx, arg0, 0x0);
    let v5 = constructor_value_regs_get_gpr(ctx, arg0, 0x1);
    let v7 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v8 = constructor_x64_shr(ctx, I64, v3, v7);
    let v9 = &C::gpr_to_imm8_gpr(ctx, arg1);
    let v10 = constructor_x64_sar(ctx, I64, v5, v9);
    let v12 = constructor_imm(ctx, I64, 0x40);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, arg1);
    let v15 = constructor_x64_sub(ctx, I64, v13, v14);
    let v16 = &C::gpr_to_imm8_gpr(ctx, v15);
    let v17 = constructor_x64_shl(ctx, I64, v5, v16);
    let v20 = RegMemImm::Imm { simm32: 0x7F };
    let v21 = &C::gpr_mem_imm_new(ctx, &v20);
    let v22 = &constructor_x64_test(ctx, &OperandSize::Size64, v21, arg1);
    let v25 = constructor_imm(ctx, I64, 0x0);
    let v26 = &C::reg_to_gpr_mem(ctx, v25);
    let v27 = &constructor_cmove(ctx, I64, &CC::Z, v26, v17);
    let v28 = constructor_with_flags_reg(ctx, v22, v27);
    let v29 = C::gpr_new(ctx, v28);
    let v30 = &C::gpr_to_gpr_mem_imm(ctx, v29);
    let v31 = constructor_x64_or(ctx, I64, v8, v30);
    let v33 = &C::imm8_to_imm8_gpr(ctx, 0x3F);
    let v34 = constructor_x64_sar(ctx, I64, v5, v33);
    let v36 = RegMemImm::Imm { simm32: 0x40 };
    let v37 = &C::gpr_mem_imm_new(ctx, &v36);
    let v38 = &constructor_x64_test(ctx, &OperandSize::Size64, v37, arg1);
    let v39 = &C::gpr_to_gpr_mem(ctx, v31);
    let v40 = &constructor_cmove(ctx, I64, &CC::Z, v39, v10);
    let v41 = &C::gpr_to_gpr_mem(ctx, v10);
    let v42 = &constructor_cmove(ctx, I64, &CC::Z, v41, v34);
    let v43 = &constructor_consumes_flags_concat(ctx, v40, v42);
    let v44 = constructor_with_flags(ctx, v38, v43);
    // Rule at src/isa/x64/lower.isle line 601.
    return v44;
}
// Generated as internal constructor for term sshr_i8x16_bigger_shift.
pub fn constructor_sshr_i8x16_bigger_shift<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &RegMemImm,
) -> XmmMemImm {
    match arg1 {
        &RegMemImm::Reg { reg: v7 } => {
            let v8 = C::gpr_new(ctx, v7);
            let v9 = RegMemImm::Imm { simm32: 0x8 };
            let v10 = &C::gpr_mem_imm_new(ctx, &v9);
            let v11 = constructor_x64_add(ctx, arg0, v8, v10);
            let v12 = C::gpr_to_reg(ctx, v11);
            let v13 = RegMemImm::Reg { reg: v12 };
            let v14 = &constructor_mov_rmi_to_xmm(ctx, &v13);
            // Rule at src/isa/x64/lower.isle line 669.
            return v14.clone();
        }
        &RegMemImm::Mem { addr: ref v15 } => {
            let v17 = constructor_imm(ctx, arg0, 0x8);
            let v18 = C::gpr_new(ctx, v17);
            let v19 = &C::gpr_mem_imm_new(ctx, arg1);
            let v20 = constructor_x64_add(ctx, arg0, v18, v19);
            let v21 = C::gpr_to_reg(ctx, v20);
            let v22 = RegMemImm::Reg { reg: v21 };
            let v23 = &constructor_mov_rmi_to_xmm(ctx, &v22);
            // Rule at src/isa/x64/lower.isle line 673.
            return v23.clone();
        }
        &RegMemImm::Imm { simm32: v2 } => {
            let v4 = C::u32_add(ctx, v2, 0x8);
            let v5 = RegMemImm::Imm { simm32: v4 };
            let v6 = &C::xmm_mem_imm_new(ctx, &v5);
            // Rule at src/isa/x64/lower.isle line 667.
            return v6.clone();
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "sshr_i8x16_bigger_shift", "src/isa/x64/lower.isle line 666"
    )
}
// Generated as internal constructor for term lower_bmask.
pub fn constructor_lower_bmask<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Type,
    arg2: ValueRegs,
) -> ValueRegs {
    if arg0 == I128 {
        let v23 = constructor_lower_bmask(ctx, I64, arg1, arg2);
        let v24 = constructor_value_regs_get_gpr(ctx, v23, 0x0);
        let v25 = C::gpr_to_reg(ctx, v24);
        let v26 = C::gpr_to_reg(ctx, v24);
        let v27 = C::value_regs(ctx, v25, v26);
        // Rule at src/isa/x64/lower.isle line 1146.
        return v27;
    }
    let v1 = C::fits_in_64(ctx, arg0);
    if let Some(v2) = v1 {
        if arg1 == I128 {
            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);
            let v16 = constructor_value_regs_get_gpr(ctx, arg2, 0x1);
            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v16);
            let v19 = constructor_x64_or(ctx, I64, v8, v18);
            let v20 = C::gpr_to_reg(ctx, v19);
            let v21 = C::value_reg(ctx, v20);
            let v22 = constructor_lower_bmask(ctx, v2, I64, v21);
            // Rule at src/isa/x64/lower.isle line 1138.
            return v22;
        }
        let v4 = C::fits_in_64(ctx, arg1);
        if let Some(v5) = v4 {
            let v8 = constructor_value_regs_get_gpr(ctx, arg2, 0x0);
            let v9 = &constructor_x64_neg_paired(ctx, v5, v8);
            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v8);
            let v11 = &constructor_x64_sbb_paired(ctx, v2, v8, v10);
            let v12 = constructor_with_flags(ctx, v9, v11);
            let v14 = C::value_regs_get(ctx, v12, 0x1);
            let v15 = C::value_reg(ctx, v14);
            // Rule at src/isa/x64/lower.isle line 1127.
            return v15;
        }
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "lower_bmask", "src/isa/x64/lower.isle line 1115"
    )
}
// Generated as internal constructor for term i128_not.
pub fn constructor_i128_not<C: Context>(ctx: &mut C, arg0: Value) -> ValueRegs {
    let v1 = C::put_in_regs(ctx, arg0);
    let v3 = constructor_value_regs_get_gpr(ctx, v1, 0x0);
    let v5 = constructor_value_regs_get_gpr(ctx, v1, 0x1);
    let v7 = constructor_x64_not(ctx, I64, v3);
    let v8 = constructor_x64_not(ctx, I64, v5);
    let v9 = constructor_value_gprs(ctx, v7, v8);
    // Rule at src/isa/x64/lower.isle line 1169.
    return v9;
}
// Generated as internal constructor for term all_ones_or_all_zeros.
pub fn constructor_all_ones_or_all_zeros<C: Context>(ctx: &mut C, arg0: Value) -> Option<bool> {
    let v1 = C::def_inst(ctx, arg0);
    if let Some(v2) = v1 {
        let v3 = &C::inst_data(ctx, v2);
        match v3 {
            &InstructionData::FloatCompare {
                opcode: ref v16,
                args: ref v17,
                cond: ref v18,
            } => {
                if let &Opcode::Fcmp = v16 {
                    let v10 = C::value_type(ctx, arg0);
                    let v11 = C::multi_lane(ctx, v10);
                    if let Some(v12) = v11 {
                        // Rule at src/isa/x64/lower.isle line 1217.
                        return Some(true);
                    }
                }
            }
            &InstructionData::IntCompare {
                opcode: ref v4,
                args: ref v5,
                cond: ref v6,
            } => {
                if let &Opcode::Icmp = v4 {
                    let v10 = C::value_type(ctx, arg0);
                    let v11 = C::multi_lane(ctx, v10);
                    if let Some(v12) = v11 {
                        // Rule at src/isa/x64/lower.isle line 1216.
                        return Some(true);
                    }
                }
            }
            &InstructionData::UnaryConst {
                opcode: ref v22,
                constant_handle: v23,
            } => {
                if let &Opcode::Vconst = v22 {
                    let v24 = C::vconst_all_ones_or_all_zeros(ctx, v23);
                    if let Some(v25) = v24 {
                        // Rule at src/isa/x64/lower.isle line 1218.
                        return Some(true);
                    }
                }
            }
            _ => {}
        }
    }
    None
}
// Generated as internal constructor for term vec_insert_lane.
pub fn constructor_vec_insert_lane<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Xmm,
    arg2: &RegMem,
    arg3: u8,
) -> Xmm {
    match arg0 {
        I8X16 => {
            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);
            let v5 = constructor_x64_pinsrb(ctx, arg1, v4, arg3);
            // Rule at src/isa/x64/lower.isle line 1250.
            return v5;
        }
        I16X8 => {
            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);
            let v6 = constructor_x64_pinsrw(ctx, arg1, v4, arg3);
            // Rule at src/isa/x64/lower.isle line 1254.
            return v6;
        }
        I32X4 => {
            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);
            let v7 = constructor_x64_pinsrd(ctx, arg1, v4, arg3);
            // Rule at src/isa/x64/lower.isle line 1258.
            return v7;
        }
        I64X2 => {
            let v4 = &C::reg_mem_to_gpr_mem(ctx, arg2);
            let v8 = constructor_x64_pinsrq(ctx, arg1, v4, arg3);
            // Rule at src/isa/x64/lower.isle line 1262.
            return v8;
        }
        F32X4 => {
            let v9 = &C::reg_mem_to_xmm_mem(ctx, arg2);
            let v10 = C::sse_insertps_lane_imm(ctx, arg3);
            let v11 = constructor_x64_insertps(ctx, arg1, v9, v10);
            // Rule at src/isa/x64/lower.isle line 1266.
            return v11;
        }
        F64X2 => {
            match arg3 {
                0x0 => {
                    match arg2 {
                        &RegMem::Reg { reg: v12 } => {
                            let v13 = C::xmm_new(ctx, v12);
                            let v14 = constructor_x64_movsd_regmove(ctx, arg1, v13);
                            // Rule at src/isa/x64/lower.isle line 1278.
                            return v14;
                        }
                        &RegMem::Mem { addr: ref v15 } => {
                            let v16 = constructor_x64_movsd_load(ctx, v15);
                            let v17 = constructor_x64_movsd_regmove(ctx, arg1, v16);
                            // Rule at src/isa/x64/lower.isle line 1280.
                            return v17;
                        }
                        _ => {}
                    }
                }
                0x1 => {
                    let v9 = &C::reg_mem_to_xmm_mem(ctx, arg2);
                    let v18 = constructor_x64_movlhps(ctx, arg1, v9);
                    // Rule at src/isa/x64/lower.isle line 1288.
                    return v18;
                }
                _ => {}
            }
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "vec_insert_lane", "src/isa/x64/lower.isle line 1247"
    )
}
// Generated as internal constructor for term cmp_and_choose.
pub fn constructor_cmp_and_choose<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &CC,
    arg2: Value,
    arg3: Value,
) -> ValueRegs {
    let v1 = C::fits_in_64(ctx, arg0);
    if let Some(v2) = v1 {
        let v6 = &C::raw_operand_size_of_type(ctx, v2);
        let v7 = C::put_in_reg(ctx, arg2);
        let v8 = C::put_in_reg(ctx, arg3);
        let v9 = &constructor_reg_to_gpr_mem_imm(ctx, v7);
        let v10 = C::gpr_new(ctx, v8);
        let v11 = &constructor_x64_cmp(ctx, v6, v9, v10);
        let v12 = &C::reg_to_gpr_mem(ctx, v8);
        let v13 = C::gpr_new(ctx, v7);
        let v14 = &constructor_cmove(ctx, v2, arg1, v12, v13);
        let v15 = constructor_with_flags_reg(ctx, v11, v14);
        let v16 = C::value_reg(ctx, v15);
        // Rule at src/isa/x64/lower.isle line 1296.
        return v16;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "cmp_and_choose", "src/isa/x64/lower.isle line 1295"
    )
}
// Generated as internal constructor for term lower_select_fcmp.
pub fn constructor_lower_select_fcmp<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: &FcmpCondResult,
    arg2: Value,
    arg3: Value,
) -> InstOutput {
    match arg1 {
        &FcmpCondResult::Condition {
            producer: ref v2,
            cc: ref v3,
        } => {
            let v6 = &constructor_cmove_from_values(ctx, arg0, v3, arg2, arg3);
            let v7 = constructor_with_flags(ctx, v2, v6);
            let v8 = C::output(ctx, v7);
            // Rule at src/isa/x64/lower.isle line 1588.
            return v8;
        }
        &FcmpCondResult::OrCondition {
            producer: ref v9,
            cc1: ref v10,
            cc2: ref v11,
        } => {
            let v12 = &constructor_cmove_or_from_values(ctx, arg0, v10, v11, arg2, arg3);
            let v13 = constructor_with_flags(ctx, v9, v12);
            let v14 = C::output(ctx, v13);
            // Rule at src/isa/x64/lower.isle line 1590.
            return v14;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "lower_select_fcmp", "src/isa/x64/lower.isle line 1587"
    )
}
// Generated as internal constructor for term do_clz.
pub fn constructor_do_clz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {
    let v5 = constructor_imm_i64(ctx, I64, -0x1);
    let v6 = C::gpr_new(ctx, v5);
    let v7 = constructor_bsr_or_else(ctx, arg0, arg2, v6);
    let v8 = C::gpr_to_reg(ctx, v7);
    let v9 = C::ty_bits_u64(ctx, arg1);
    let v11 = C::u64_sub(ctx, v9, 0x1);
    let v12 = constructor_imm(ctx, arg0, v11);
    let v13 = C::gpr_new(ctx, v12);
    let v14 = &constructor_reg_to_gpr_mem_imm(ctx, v8);
    let v15 = constructor_x64_sub(ctx, arg0, v13, v14);
    // Rule at src/isa/x64/lower.isle line 1656.
    return v15;
}
// Generated as internal constructor for term do_ctz.
pub fn constructor_do_ctz<C: Context>(ctx: &mut C, arg0: Type, arg1: Type, arg2: Gpr) -> Gpr {
    let v4 = C::ty_bits_u64(ctx, arg1);
    let v5 = constructor_imm(ctx, I64, v4);
    let v6 = C::gpr_new(ctx, v5);
    let v7 = constructor_bsf_or_else(ctx, arg0, arg2, v6);
    // Rule at src/isa/x64/lower.isle line 1699.
    return v7;
}
// Generated as internal constructor for term do_popcnt.
pub fn constructor_do_popcnt<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    match arg0 {
        I32 => {
            let v4 = Imm8Reg::Imm8 { imm: 0x1 };
            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v47 = constructor_x64_shr(ctx, I32, arg1, v5);
            let v49 = constructor_imm(ctx, I32, 0x77777777);
            let v50 = C::gpr_new(ctx, v49);
            let v51 = &C::gpr_to_gpr_mem_imm(ctx, v50);
            let v52 = constructor_x64_and(ctx, I32, v47, v51);
            let v53 = &C::gpr_to_gpr_mem_imm(ctx, v52);
            let v54 = constructor_x64_sub(ctx, I32, arg1, v53);
            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v55 = constructor_x64_shr(ctx, I32, v52, v14);
            let v56 = &C::gpr_to_gpr_mem_imm(ctx, v50);
            let v57 = constructor_x64_and(ctx, I32, v55, v56);
            let v58 = &C::gpr_to_gpr_mem_imm(ctx, v57);
            let v59 = constructor_x64_sub(ctx, I32, v54, v58);
            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v60 = constructor_x64_shr(ctx, I32, v57, v20);
            let v61 = &C::gpr_to_gpr_mem_imm(ctx, v50);
            let v62 = constructor_x64_and(ctx, I32, v60, v61);
            let v63 = &C::gpr_to_gpr_mem_imm(ctx, v62);
            let v64 = constructor_x64_sub(ctx, I32, v59, v63);
            let v27 = Imm8Reg::Imm8 { imm: 0x4 };
            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);
            let v65 = constructor_x64_shr(ctx, I32, v64, v28);
            let v66 = &C::gpr_to_gpr_mem_imm(ctx, v64);
            let v67 = constructor_x64_add(ctx, I32, v65, v66);
            let v69 = RegMemImm::Imm { simm32: 0xF0F0F0F };
            let v70 = &C::gpr_mem_imm_new(ctx, &v69);
            let v71 = constructor_x64_and(ctx, I32, v67, v70);
            let v73 = RegMemImm::Imm { simm32: 0x1010101 };
            let v74 = &C::gpr_mem_imm_new(ctx, &v73);
            let v75 = constructor_x64_mul(ctx, I32, v71, v74);
            let v77 = Imm8Reg::Imm8 { imm: 0x18 };
            let v78 = &C::imm8_reg_to_imm8_gpr(ctx, &v77);
            let v79 = constructor_x64_shr(ctx, I32, v75, v78);
            // Rule at src/isa/x64/lower.isle line 1790.
            return v79;
        }
        I64 => {
            let v4 = Imm8Reg::Imm8 { imm: 0x1 };
            let v5 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v6 = constructor_x64_shr(ctx, I64, arg1, v5);
            let v8 = constructor_imm(ctx, I64, 0x7777777777777777);
            let v9 = C::gpr_new(ctx, v8);
            let v10 = &C::gpr_to_gpr_mem_imm(ctx, v9);
            let v11 = constructor_x64_and(ctx, I64, v6, v10);
            let v12 = &C::gpr_to_gpr_mem_imm(ctx, v11);
            let v13 = constructor_x64_sub(ctx, I64, arg1, v12);
            let v14 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v15 = constructor_x64_shr(ctx, I64, v11, v14);
            let v16 = &C::gpr_to_gpr_mem_imm(ctx, v9);
            let v17 = constructor_x64_and(ctx, I64, v15, v16);
            let v18 = &C::gpr_to_gpr_mem_imm(ctx, v17);
            let v19 = constructor_x64_sub(ctx, I64, v13, v18);
            let v20 = &C::imm8_reg_to_imm8_gpr(ctx, &v4);
            let v21 = constructor_x64_shr(ctx, I64, v17, v20);
            let v22 = &C::gpr_to_gpr_mem_imm(ctx, v9);
            let v23 = constructor_x64_and(ctx, I64, v21, v22);
            let v24 = &C::gpr_to_gpr_mem_imm(ctx, v23);
            let v25 = constructor_x64_sub(ctx, I64, v19, v24);
            let v27 = Imm8Reg::Imm8 { imm: 0x4 };
            let v28 = &C::imm8_reg_to_imm8_gpr(ctx, &v27);
            let v29 = constructor_x64_shr(ctx, I64, v25, v28);
            let v30 = &C::gpr_to_gpr_mem_imm(ctx, v25);
            let v31 = constructor_x64_add(ctx, I64, v29, v30);
            let v33 = constructor_imm(ctx, I64, 0xF0F0F0F0F0F0F0F);
            let v34 = C::gpr_new(ctx, v33);
            let v35 = &C::gpr_to_gpr_mem_imm(ctx, v34);
            let v36 = constructor_x64_and(ctx, I64, v31, v35);
            let v38 = constructor_imm(ctx, I64, 0x101010101010101);
            let v39 = C::gpr_new(ctx, v38);
            let v40 = &C::gpr_to_gpr_mem_imm(ctx, v39);
            let v41 = constructor_x64_mul(ctx, I64, v36, v40);
            let v43 = Imm8Reg::Imm8 { imm: 0x38 };
            let v44 = &C::imm8_reg_to_imm8_gpr(ctx, &v43);
            let v45 = constructor_x64_shr(ctx, I64, v41, v44);
            // Rule at src/isa/x64/lower.isle line 1747.
            return v45;
        }
        _ => {}
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "do_popcnt", "src/isa/x64/lower.isle line 1746"
    )
}
// Generated as internal constructor for term do_bitrev8.
pub fn constructor_do_bitrev8<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = C::ty_mask(ctx, arg0);
    let v4 = C::u64_and(ctx, v2, 0x5555555555555555);
    let v5 = constructor_imm(ctx, arg0, v4);
    let v6 = C::gpr_new(ctx, v5);
    let v7 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v8 = constructor_x64_and(ctx, arg0, arg1, v7);
    let v10 = Imm8Reg::Imm8 { imm: 0x1 };
    let v11 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);
    let v12 = constructor_x64_shr(ctx, arg0, arg1, v11);
    let v13 = &C::gpr_to_gpr_mem_imm(ctx, v6);
    let v14 = constructor_x64_and(ctx, arg0, v12, v13);
    let v15 = &C::imm8_reg_to_imm8_gpr(ctx, &v10);
    let v16 = constructor_x64_shl(ctx, arg0, v8, v15);
    let v17 = &C::gpr_to_gpr_mem_imm(ctx, v14);
    let v18 = constructor_x64_or(ctx, arg0, v16, v17);
    let v20 = C::u64_and(ctx, v2, 0x3333333333333333);
    let v21 = constructor_imm(ctx, arg0, v20);
    let v22 = C::gpr_new(ctx, v21);
    let v23 = &C::gpr_to_gpr_mem_imm(ctx, v22);
    let v24 = constructor_x64_and(ctx, arg0, v18, v23);
    let v26 = Imm8Reg::Imm8 { imm: 0x2 };
    let v27 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);
    let v28 = constructor_x64_shr(ctx, arg0, v18, v27);
    let v29 = &C::gpr_to_gpr_mem_imm(ctx, v22);
    let v30 = constructor_x64_and(ctx, arg0, v28, v29);
    let v31 = &C::imm8_reg_to_imm8_gpr(ctx, &v26);
    let v32 = constructor_x64_shl(ctx, arg0, v24, v31);
    let v33 = &C::gpr_to_gpr_mem_imm(ctx, v30);
    let v34 = constructor_x64_or(ctx, arg0, v32, v33);
    let v36 = C::u64_and(ctx, v2, 0xF0F0F0F0F0F0F0F);
    let v37 = constructor_imm(ctx, arg0, v36);
    let v38 = C::gpr_new(ctx, v37);
    let v39 = &C::gpr_to_gpr_mem_imm(ctx, v38);
    let v40 = constructor_x64_and(ctx, arg0, v34, v39);
    let v42 = Imm8Reg::Imm8 { imm: 0x4 };
    let v43 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);
    let v44 = constructor_x64_shr(ctx, arg0, v34, v43);
    let v45 = &C::gpr_to_gpr_mem_imm(ctx, v38);
    let v46 = constructor_x64_and(ctx, arg0, v44, v45);
    let v47 = &C::imm8_reg_to_imm8_gpr(ctx, &v42);
    let v48 = constructor_x64_shl(ctx, arg0, v40, v47);
    let v49 = &C::gpr_to_gpr_mem_imm(ctx, v46);
    let v50 = constructor_x64_or(ctx, arg0, v48, v49);
    // Rule at src/isa/x64/lower.isle line 1879.
    return v50;
}
// Generated as internal constructor for term do_bitrev16.
pub fn constructor_do_bitrev16<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = constructor_do_bitrev8(ctx, arg0, arg1);
    let v3 = C::ty_mask(ctx, arg0);
    let v5 = C::u64_and(ctx, v3, 0xFF00FF00FF00FF);
    let v6 = constructor_imm(ctx, arg0, v5);
    let v7 = C::gpr_new(ctx, v6);
    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v9 = constructor_x64_and(ctx, arg0, v2, v8);
    let v11 = Imm8Reg::Imm8 { imm: 0x8 };
    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);
    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v15 = constructor_x64_and(ctx, arg0, v13, v14);
    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);
    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);
    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);
    let v19 = constructor_x64_or(ctx, arg0, v17, v18);
    // Rule at src/isa/x64/lower.isle line 1902.
    return v19;
}
// Generated as internal constructor for term do_bitrev32.
pub fn constructor_do_bitrev32<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    let v2 = constructor_do_bitrev16(ctx, arg0, arg1);
    let v3 = C::ty_mask(ctx, arg0);
    let v5 = C::u64_and(ctx, v3, 0xFFFF0000FFFF);
    let v6 = constructor_imm(ctx, arg0, v5);
    let v7 = C::gpr_new(ctx, v6);
    let v8 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v9 = constructor_x64_and(ctx, arg0, v2, v8);
    let v11 = Imm8Reg::Imm8 { imm: 0x10 };
    let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);
    let v13 = constructor_x64_shr(ctx, arg0, v2, v12);
    let v14 = &C::gpr_to_gpr_mem_imm(ctx, v7);
    let v15 = constructor_x64_and(ctx, arg0, v13, v14);
    let v16 = &C::imm8_reg_to_imm8_gpr(ctx, &v11);
    let v17 = constructor_x64_shl(ctx, arg0, v9, v16);
    let v18 = &C::gpr_to_gpr_mem_imm(ctx, v15);
    let v19 = constructor_x64_or(ctx, arg0, v17, v18);
    // Rule at src/isa/x64/lower.isle line 1914.
    return v19;
}
// Generated as internal constructor for term do_bitrev64.
pub fn constructor_do_bitrev64<C: Context>(ctx: &mut C, arg0: Type, arg1: Gpr) -> Gpr {
    if arg0 == I64 {
        let v2 = constructor_do_bitrev32(ctx, arg0, arg1);
        let v4 = constructor_imm(ctx, arg0, 0xFFFFFFFF);
        let v5 = C::gpr_new(ctx, v4);
        let v6 = &C::gpr_to_gpr_mem_imm(ctx, v5);
        let v7 = constructor_x64_and(ctx, arg0, v2, v6);
        let v9 = Imm8Reg::Imm8 { imm: 0x20 };
        let v10 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);
        let v11 = constructor_x64_shr(ctx, arg0, v2, v10);
        let v12 = &C::imm8_reg_to_imm8_gpr(ctx, &v9);
        let v13 = constructor_x64_shl(ctx, arg0, v7, v12);
        let v14 = &C::gpr_to_gpr_mem_imm(ctx, v11);
        let v15 = constructor_x64_or(ctx, arg0, v13, v14);
        // Rule at src/isa/x64/lower.isle line 1926.
        return v15;
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "do_bitrev64", "src/isa/x64/lower.isle line 1925"
    )
}
// Generated as internal constructor for term fmadd.
pub fn constructor_fmadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v24 = C::def_inst(ctx, arg2);
    if let Some(v25) = v24 {
        let v26 = &C::inst_data(ctx, v25);
        if let &InstructionData::Unary {
            opcode: ref v27,
            arg: v28,
        } = v26
        {
            if let &Opcode::Fneg = v27 {
                let v29 = constructor_fnmadd(ctx, arg0, arg1, v28, arg3);
                // Rule at src/isa/x64/lower.isle line 2381.
                return v29;
            }
        }
    }
    let v18 = C::def_inst(ctx, arg1);
    if let Some(v19) = v18 {
        let v20 = &C::inst_data(ctx, v19);
        if let &InstructionData::Unary {
            opcode: ref v21,
            arg: v22,
        } = v20
        {
            if let &Opcode::Fneg = v21 {
                let v23 = constructor_fnmadd(ctx, arg0, v22, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 2380.
                return v23;
            }
        }
    }
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfmadd132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 2376.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfmadd132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 2375.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfmadd213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 2370.
    return v7;
}
// Generated as internal constructor for term fnmadd.
pub fn constructor_fnmadd<C: Context>(
    ctx: &mut C,
    arg0: Type,
    arg1: Value,
    arg2: Value,
    arg3: Value,
) -> Xmm {
    let v24 = C::def_inst(ctx, arg2);
    if let Some(v25) = v24 {
        let v26 = &C::inst_data(ctx, v25);
        if let &InstructionData::Unary {
            opcode: ref v27,
            arg: v28,
        } = v26
        {
            if let &Opcode::Fneg = v27 {
                let v29 = constructor_fmadd(ctx, arg0, arg1, v28, arg3);
                // Rule at src/isa/x64/lower.isle line 2389.
                return v29;
            }
        }
    }
    let v18 = C::def_inst(ctx, arg1);
    if let Some(v19) = v18 {
        let v20 = &C::inst_data(ctx, v19);
        if let &InstructionData::Unary {
            opcode: ref v21,
            arg: v22,
        } = v20
        {
            if let &Opcode::Fneg = v21 {
                let v23 = constructor_fmadd(ctx, arg0, v22, arg2, arg3);
                // Rule at src/isa/x64/lower.isle line 2388.
                return v23;
            }
        }
    }
    let v14 = &C::sinkable_load(ctx, arg2);
    if let Some(v15) = v14 {
        let v4 = constructor_put_in_xmm(ctx, arg1);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v16 = &constructor_sink_load_to_xmm_mem(ctx, v15);
        let v17 = constructor_x64_vfnmadd132(ctx, arg0, v4, v11, v16);
        // Rule at src/isa/x64/lower.isle line 2385.
        return v17;
    }
    let v8 = &C::sinkable_load(ctx, arg1);
    if let Some(v9) = v8 {
        let v10 = constructor_put_in_xmm(ctx, arg2);
        let v11 = constructor_put_in_xmm(ctx, arg3);
        let v12 = &constructor_sink_load_to_xmm_mem(ctx, v9);
        let v13 = constructor_x64_vfnmadd132(ctx, arg0, v10, v11, v12);
        // Rule at src/isa/x64/lower.isle line 2384.
        return v13;
    }
    let v4 = constructor_put_in_xmm(ctx, arg1);
    let v5 = constructor_put_in_xmm(ctx, arg2);
    let v6 = &C::put_in_xmm_mem(ctx, arg3);
    let v7 = constructor_x64_vfnmadd213(ctx, arg0, v4, v5, v6);
    // Rule at src/isa/x64/lower.isle line 2383.
    return v7;
}
// Generated as internal constructor for term cmp_zero_i128.
pub fn constructor_cmp_zero_i128<C: Context>(
    ctx: &mut C,
    arg0: &CC,
    arg1: ValueRegs,
) -> IcmpCondResult {
    let v1 = &C::cc_nz_or_z(ctx, arg0);
    if let Some(v2) = v1 {
        let v5 = constructor_value_regs_get_gpr(ctx, arg1, 0x0);
        let v7 = constructor_value_regs_get_gpr(ctx, arg1, 0x1);
        let v10 = RegMemImm::Imm { simm32: 0x0 };
        let v11 = &C::gpr_mem_imm_new(ctx, &v10);
        let v12 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v11, v5);
        let v14 = &constructor_x64_setcc(ctx, &CC::Z);
        let v15 = constructor_with_flags_reg(ctx, v12, v14);
        let v16 = C::gpr_new(ctx, v15);
        let v17 = &C::gpr_mem_imm_new(ctx, &v10);
        let v18 = &constructor_x64_cmp(ctx, &OperandSize::Size64, v17, v7);
        let v19 = &constructor_x64_setcc(ctx, &CC::Z);
        let v20 = constructor_with_flags_reg(ctx, v18, v19);
        let v21 = C::gpr_new(ctx, v20);
        let v23 = &C::gpr_to_gpr_mem_imm(ctx, v16);
        let v24 = &constructor_x64_test(ctx, &OperandSize::Size8, v23, v21);
        let v25 = &constructor_icmp_cond_result(ctx, v24, v2);
        // Rule at src/isa/x64/lower.isle line 2821.
        return v25.clone();
    }
    unreachable!(
        "no rule matched for term {} at {}; should it be partial?",
        "cmp_zero_i128", "src/isa/x64/lower.isle line 2820"
    )
}
// Generated as internal constructor for term cmp_zero_int_bool_ref.
pub fn constructor_cmp_zero_int_bool_ref<C: Context>(ctx: &mut C, arg0: Value) -> ProducesFlags {
    let v1 = C::value_type(ctx, arg0);
    let v2 = &C::raw_operand_size_of_type(ctx, v1);
    let v3 = constructor_put_in_gpr(ctx, arg0);
    let v4 = &C::gpr_to_gpr_mem_imm(ctx, v3);
    let v5 = &constructor_x64_test(ctx, v2, v4, v3);
    // Rule at src/isa/x64/lower.isle line 2832.
    return v5.clone();
}
// Generated as internal constructor for term nonzero_sdiv_divisor.
pub fn constructor_nonzero_sdiv_divisor<C: Context>(ctx: &mut C, arg0: Type, arg1: Value) -> Reg {
    let v2 = C::def_inst(ctx, arg1);
    if let Some(v3) = v2 {
        let v4 = &C::inst_data(ctx, v3);
        if let &InstructionData::UnaryImm {
            opcode: ref v5,
            imm: v6,
        } = v4
        {
            if let &Opcode::Iconst = v5 {
                let v7 = C::safe_divisor_from_imm64(ctx, arg0, v6);
                if let Some(v8) = v7 {
                    let v9 = constructor_imm(ctx, arg0, v8);
                    // Rule at src/isa/x64/lower.isle line 3425.
                    return v9;
                }
            }
        }
    }
    let v10 = C::put_in_reg(ctx, arg1);
    let v11 = &C::raw_operand_size_of_type(ctx, arg0);
    let v12 = &constructor_reg_to_gpr_mem_imm(ctx, v10);
    let v13 = C::gpr_new(ctx, v10);
    let v14 = &constructor_x64_test(ctx, v11, v12, v13);
    let v17 = &constructor_trap_if(ctx, &CC::Z, &TrapCode::IntegerDivisionByZero);
    let v18 = &constructor_with_flags_side_effect(ctx, v14, v17);
    let v19 = constructor_side_effect(ctx, v18);
    // Rule at src/isa/x64/lower.isle line 3428.
    return v10;
}